<?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">"Yebo"</string>
    <string name="no" msgid="5541738710521607130">"Cha"</string>
    <string name="create" msgid="986997212165228751">"Yakha"</string>
    <string name="allow" msgid="3763244945363657722">"Vumela"</string>
    <string name="deny" msgid="7326117222944479942">"Nqaba"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Vula"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Akwaziwa"</string>
    <string name="device_info_protected_single_press" msgid="3810785480060743677">"Thepha ukuze ubonise ulwazi"</string>
    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{Manje usalelwe yisinyathelo esi-# ukuthi ube ngunjiniyela.}one{Manje usalelwe yizinyathelo ezingu-# ukuthi ube ngunjiniyela.}other{Manje usalelwe yizinyathelo ezingu-# ukuthi ube ngunjiniyela.}}"</string>
    <string name="show_dev_on" msgid="2840850085134853754">"Manje ungunjiniyela!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Asikho isidingo, usuvele ungunjiniyela."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Sicela unike amandla izinketho zokuthuthukisa kuqala."</string>
    <string name="dev_settings_available_to_admin_only_warning" msgid="3408243404879083111">"Abasebenzisi abangabaphathi kuphela abangafinyelela amasethingi onjiniyela."</string>
    <string name="header_category_system" msgid="1665516346845259058">"Isistimu"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"Kwisevisi"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Ayikho isevisi"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Irediyo ivaliwe"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Iyazulazula"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Ayizulazuli"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Ayixhunyiwe kwi-inthanethi"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Ixhunyiwe"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Ixhunyiwe"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Kumiswe okwesikhashana"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Akwaziwa"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Hlola kuqala"</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Yenza kube kuncane"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Yenza kube kukhulu"</string>
    <string name="stay_awake_on_fold_title" msgid="6590454679898134221">"Njalo"</string>
    <string name="stay_awake_on_fold_summary" msgid="1939963751585954262">"Isibonisi sangaphambili siyakhanya uma ugoqa idivayisi yakho"</string>
    <string name="selective_stay_awake_title" msgid="7887645333447645168">"Amageyimu kuphela, amavidiyo, nokuningi"</string>
    <string name="selective_stay_awake_summary" msgid="9055967322921984543">"Isibonisi sangaphambili siyakhanya lapho unama-app avimba isikrini sakho ukuthi siphumule"</string>
    <string name="stay_awake_on_lockscreen_title" msgid="8088456642083051068">"Swayipha ukuze uqhubeke"</string>
    <string name="stay_awake_on_lockscreen_summary" msgid="2299351813382522952">"Goqa ifoni yakho bese uswayipha uye phezulu kusibonisi sangaphambili ukuze uqhubeke usebenzisa i-app, noma ulinde imizuzwana embalwa ukuze isikrini sikhiye"</string>
    <string name="sleep_on_fold_title" msgid="7626123024330501411">"Ungalokothi"</string>
    <string name="sleep_on_fold_summary" msgid="7737992842459588846">"Isibonisi sangaphambili siyakhiya uma ugoqa idivayisi yakho"</string>
    <string name="auto_rotate_settings_primary_switch_title" msgid="3440951924928594520">"Sebenzisa ukuphenduka okuzenzakalelayo"</string>
    <string name="smart_rotate_text_headline" msgid="5878008933992951904">"Ukutholwa Kobuso kusebenzisa ikhamera ebheke phambili ukuthuthukisa ukunemba kokuphenduka okuzenzakalelayo. Izithombe azilondolozwa noma zithunyelwe ku-Google."</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Ibonakala kuwo wonke amadivayisi e-Bluetooth (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Iyabonakala kuwo wonke amadivaysi aseduze we-Bluetooth"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Ayibonakali kwamanye amadivayisi e-Bluetooth"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Ibonakala kuphela kumadivayisi apheyiwe"</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Amadivaysi e-Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Igama ledivaysi"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Qamba kabusha le divayisi"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Qamba kabusha"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Nqamula idivayisi?"</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Bhangqa idivayisi entsha"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"i-bluetooth"</string>
    <string name="bluetooth_screen_auto_on_title" msgid="8496443490064988240">"Vula ngokuzenzekela futhi kusasa"</string>
    <string name="bluetooth_pair_right_ear_button" msgid="3979894494803078852">"Bhangqa indlebe engakwesokudla"</string>
    <string name="bluetooth_pair_left_ear_button" msgid="1019938875726073791">"Bhangqa indlebe engakwesokunxele"</string>
    <string name="bluetooth_pair_other_ear_dialog_title" msgid="3814943511999984012">"Bhangqa enye indlebe yakho"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_message" msgid="5711642363615781647">"Insizakuzwa yakho engakwesokunxele ixhunyiwe.\n\nUkuze ubhangqe engakwesokudla, qinisekisa ukuthi ivuliwe futhi ikulungele ukubhangqa."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message" msgid="631521133525979967">"Insizakuzwa yakho engakwesokudla ixhunyiwe.\n\nUkuze ubhangqe engakwesokunxele, qinisekisa ukuthi ivuliwe futhi ikulungele ukubhangqa."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Bhangqa indlebe engakwesokudla"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Bhangqa indlebe engakwesokunxele"</string>
    <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Mayelana nawo wonke amadivayisi wokuzwa atholakalayo"</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">"Kule divayisi"</string>
    <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Okukhishwayo komsindo"</string>
    <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Mayelana nokuphumayo komsindo"</string>
    <string name="bluetooth_audio_routing_summary" msgid="7180947533985969066">"Imisindo yomzila iye kudivayisi yakho yokuzwa noma kusipikha sefoni"</string>
    <string name="bluetooth_screen_related" msgid="7976543255501825536">"Okuhambisanayo"</string>
    <string name="bluetooth_ringtone_title" msgid="3177308461256892085">"ithoni yokukhala nama-alamu"</string>
    <string name="bluetooth_call_title" msgid="6851464952021874072">"Umsindo phakathi nezingcingo"</string>
    <string name="bluetooth_media_title" msgid="2878373577382067290">"Imisindo yemidiya nesistimu"</string>
    <string name="bluetooth_notification_title" msgid="8708962394926222039">"Izaziso"</string>
    <string name="bluetooth_audio_routing_footer_summary" msgid="410260713589309293">"Ngokuzenzakalelayo, okukhipha umsindo kunqunywa ama-app angawodwana"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Idivayisi ye-Bluetooth engaqanjwanga igama"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Iyasesha..."</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"Awekho amadivayisi e-Bluetooth atholakele."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Isicelo sokubhanqa i-Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Isicelo sokubhangqa"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Thepha ukuze ubhanqe ne-<xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"I-Bluetooth ivaliwe"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Thepha ukuze uyivule"</string>
    <string name="device_picker" msgid="2427027896389445414">"Khetha idivayisi ye-Bluetooth"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"<xliff:g id="APP_NAME">%1$s</xliff:g> ifuna ukuvula i-Bluetooth"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"<xliff:g id="APP_NAME">%1$s</xliff:g> ufuna ukuvula i-Bluetooth"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"Uhlelo lokusebenza lifuna ukuvula i-Bluetooth"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"Uhlelo lokusebenza lifuna ukuvala i-Bluetooth"</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Ivula i-Bluetooth"</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Ivala i-Bluetooth"</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Isicelo sohleloxhumano lwe-Bluetooth"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Isicelo sokufinyelela ibhuku lefoni"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Isicelo sokufinyelela umlayezo"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Kubonakala njenge-\"<xliff:g id="DEVICE_NAME">^1</xliff:g>\" kwamanye amadivayisi"</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Vula i-Bluetooth ukuze ixhumeke kwamanye amadivayisi."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Amadivayisi akho"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Bhangqa idivayisi entsha"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Khubaza i-Bluetooth A2DP hardware offload"</string>
    <string name="bluetooth_disable_le_audio_hw_offload" msgid="4656853795514691257">"Khubaza ukwehliswa kwehadiwe yomsindo we-Bluetooth LE"</string>
    <string name="bluetooth_disable_hw_offload_dialog_title" msgid="6001142380445276918">"Qalisa kabusha idivayisi?"</string>
    <string name="bluetooth_disable_hw_offload_dialog_message" msgid="1524373895333698779">"Udinga ukuqalisa kabusha idivayisi yakho ukushintsha leli sethingi."</string>
    <string name="bluetooth_disable_hw_offload_dialog_confirm" msgid="5594859658551707592">"Qala kabusha"</string>
    <string name="bluetooth_disable_hw_offload_dialog_cancel" msgid="3663690305043973720">"Khansela"</string>
    <string name="bluetooth_disable_leaudio" msgid="8619410595945155354">"Khubaza umsindo we-Bluetooth LE"</string>
    <string name="bluetooth_disable_leaudio_summary" msgid="4756307633476985470">"Kukhubaza isakhi somsindo we-Bluetooth LE uma idivayisi isekela amakhono wehadiwe yomsindo we-LE."</string>
    <string name="bluetooth_leaudio_mode" msgid="5206961943393400814">"Imodi Yomsindo we-Bluetooth LE"</string>
    <string name="bluetooth_show_leaudio_device_details" msgid="3306637862550475370">"Bonisa ukuguqulwa komsindo we-LE Emininingwaneni Yedivayisi"</string>
    <string name="bluetooth_bypass_leaudio_allowlist" msgid="7392319491894565552">"Dlula Uhlu Lwabagunyaziwe Lomsindo we-Bluetooth LE"</string>
    <string name="bluetooth_bypass_leaudio_allowlist_summary" msgid="8999245286359656738">"Sebenzisa umsindo we-LE ngokuzenzakalela ngisho noma umsindo we-LE exhumekayo uqinisekisiwe ukuthi uyahlangabezane nomkhakha Wohlu Lwabagunyaziwe."</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Amadivayisi emidiya"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Shayela amadivayisi"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Amanye amadivayisi"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Amadivayisi alondoloziwe"</string>
    <string name="connected_device_fast_pair_device_title" msgid="543124539265592392">"Ehlotshaniswe ne-akhawunti yakho"</string>
    <string name="connected_device_previously_associated_fast_pair_device_title" msgid="8353405823992023457">"Kusetshenziswe ngaphambili nge-akhawunti"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"I-Bluetooth izovula ukuze ibhanqe"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Izinketho zoxhumo"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Kuxhunywe ngaphambilini"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"I-Bluetooth ivuliwe"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Buka konke"</string>
    <string name="connected_device_fast_pair_device_see_all" msgid="4898279230458128620">"Buka konke"</string>
    <string name="stylus_device_details_title" msgid="7618295136015480864">"I-Stylus"</string>
    <string name="stylus_default_notes_app" msgid="4165657465911764628">"Ukucindezela inkinobho yomsila"</string>
    <string name="stylus_default_notes_summary_work" msgid="4554643411627934223">"<xliff:g id="APP_NAME">%s</xliff:g> (Iphrofayela yomsebenzi)"</string>
    <string name="stylus_textfield_handwriting" msgid="2363579035338976327">"Bhala ezinkambini zombhalo"</string>
    <string name="stylus_ignore_button" msgid="7734540973145241391">"Ziba konke ukucindezela inkinobho ye-stylus"</string>
    <string name="stylus_connected_devices_title" msgid="2823967577941359812">"I-Stylus"</string>
    <string name="audio_streams_empty" msgid="8803517701437394982">"Akukho ukusakazwa komsindo okuseduze okutholiwe."</string>
    <string name="date_and_time" msgid="1788358029823431692">"Idethi nesikhathi"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Ummeleli"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Sula"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Imbobo yephrokzi"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Dula iphrokzi ye-"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Buyisela esimeni okumisiwe"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Kwenziwe"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Igama lomethuleli wephrokzi"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Qaphela"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"KULUNGILE"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"Igama lomethuleli olithayiphile alilungile."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"Uhlu lokukhishwayo oluthayiphile alufomethiwe kahle. Sicela ufake uhlu oluhlukaniswe ngofeleba lwezizinda ezingahlanganisiwe"</string>
    <string name="proxy_error_empty_port" msgid="4250295137005082992">"Udinga ukugcwalisa inkambu yentunja."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"Inkundla yembobo kumelwe ingabi nalutho uma inkundla yesikhungo ingenalutho."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"Imbobo oyithayiphile ayilungile."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"Iphrokzi ye-HTTP isetshenziswa isiphequluli kodwa kungenzeka ingasetshenziswa ezinye izinhlelo zokusebenza"</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"I-PAC URL: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Qhweba i-Hostname(www.google.com) IPv4:"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"Ukuhlola ikhasimende ye-HTTP:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Yenza ukuhlola kokuntwiza"</string>
    <string name="skip_label" msgid="6380034601349015895">"Yeqa"</string>
    <string name="next_label" msgid="1248293387735652187">"Okulandelayo"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Izilimi"</string>
    <string name="language_picker_category_title" msgid="1792199453060454565">"Ukuhleleka kolimi oluncanyelwayo"</string>
    <string name="desc_current_default_language" msgid="1901157141663662859">"Ulimi lwesistimu"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Susa"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Engeza ulimi"</string>
    <string name="app_locale_preference_title" msgid="5513627099300360232">"Ulimi"</string>
    <string name="locale_picker_category_title" msgid="6212064706962721255">"Ulimi oluncanyelwayo"</string>
    <string name="app_locales_picker_menu_title" msgid="7617427959223831373">"Izilimi ze-app"</string>
    <string name="app_locale_picker_summary" msgid="6742557329924446252">"Setha ulimi le-app ngayinye"</string>
    <string name="app_locale_picker_title" msgid="2431448962911301366">"Ulimi lwe-app"</string>
    <string name="suggested_app_locales_title" msgid="8898358282377369405">"Izilimi eziphakanyisiwe"</string>
    <string name="all_supported_app_locales_title" msgid="5479289964316009026">"Zonke izilimi"</string>
    <string name="preference_of_system_locale_title" msgid="8067226276038751504">"Ulimi lwesistimu"</string>
    <string name="preference_of_system_locale_summary" msgid="5612241394431188535">"Okuzenzakalelayo kwesistimu"</string>
    <string name="desc_no_available_supported_locale" msgid="7883271726226947273">"Ukukhetha ulimi kwale app akutholakali Kumasethingi."</string>
    <string name="desc_app_locale_disclaimer" msgid="5295933110644789052">"Ulimi lungahluka ezilimini ezitholakala ku-app. Amanye ama-app angase angalisekeli leli sethingi."</string>
    <string name="desc_app_locale_selection_supported" msgid="6744909281573556379">"Setha ulimi lwe-app ngayinye."</string>
    <string name="desc_introduction_of_language_picker" msgid="1038423471887102449">"Amasistimu wakho, ama-app, namawebhusayithi kusebenzisa ulimi olusekelwayo lokuqala kusuka ezilimini zakho ezincanyelwayo."</string>
    <string name="desc_notice_of_language_picker" msgid="3449290526457925447">"Ukuze ukhethe ulimi lwe-app ngayinye, iya kumasethingi wolimi lwe-app."</string>
    <string name="desc_locale_helper_footer_general" msgid="6112153921151780303">"Funda kabanzi mayelana nezilimi ze-app"</string>
    <string name="title_change_system_locale" msgid="8589844586256566951">"Shintsha ulimi lwesistimu lube yi-%s ?"</string>
    <string name="title_system_locale_addition" msgid="8218683660751479466">"Engeza u-%s kuzilimi ezikhethiwe?"</string>
    <string name="desc_system_locale_addition" msgid="3409917362651596070">"Lokhu kuvumela ama-app namawebhusayithi azi ukuthi ukhetha lolu lwimi."</string>
    <string name="desc_notice_device_locale_settings_change" msgid="8311132485850714160">"Amasethingi edivayisi yakho nokuncamelayo kwesifunda kuzoshintsha."</string>
    <string name="button_label_confirmation_of_system_locale_change" msgid="5593798559604894733">"Shintsha"</string>
    <string name="title_unavailable_locale" msgid="2628898110416542386">"i-%s ayitholakali"</string>
    <string name="desc_unavailable_locale" msgid="2201756477400935896">"Lolu limi alukwazi ukusetshenziswa njengolimi lwesistimu, kodwa uye wazisa ama-app namawebhusayithi ukuthi ukhetha lolu limi."</string>
    <string name="regional_preferences_title" msgid="4304567374498629528">"Okuncanyelwayo okungokwesifunda"</string>
    <string name="regional_preferences_summary" msgid="1189876997389469650">"Setha amayunithi kanye nezinombolo ezincanyelwayo"</string>
    <string name="regional_preferences_main_page_sub_title" msgid="4237109940015254725">"Vumela ama-app azi okuncamelayo kwesifunda ukuze aqondanise umuzwa wakho nawe."</string>
    <string name="regional_preferences_option_page_sub_title" msgid="8303661099255197036">"Ama-app azosebenzisa okuncanyelwayo kwesifunda lapho kungenzeka khona."</string>
    <string name="temperature_preferences_title" msgid="5009881556503629058">"Izinga lokushisa"</string>
    <string name="first_day_of_week_preferences_title" msgid="1971850087589599553">"Usuku lokuqala lweviki"</string>
    <string name="numbers_preferences_title" msgid="8197418984391195446">"Izintandokazi zezinombolo"</string>
    <string name="default_string_of_regional_preference" msgid="3428899072914884203">"Sebenzisa okuzenzakalelayo"</string>
    <string name="celsius_temperature_unit" msgid="8896459071273084507">"I-Celsius (°C)"</string>
    <string name="fahrenheit_temperature_unit" msgid="1118677820614569801">"I-Fahrenheit (°F)"</string>
    <string name="sunday_first_day_of_week" msgid="7644548348295686051">"ISonto"</string>
    <string name="monday_first_day_of_week" msgid="7244698610476506771">"UMsombuluko"</string>
    <string name="tuesday_first_day_of_week" msgid="5085370946936582391">"ULwesibili"</string>
    <string name="wednesday_first_day_of_week" msgid="6544537589727042869">"ULwesithathu"</string>
    <string name="thursday_first_day_of_week" msgid="3035885630945594833">"ULwesine"</string>
    <string name="friday_first_day_of_week" msgid="7074795061812083541">"ULwesihlanu"</string>
    <string name="saturday_first_day_of_week" msgid="3702282590450322727">"UMgqibelo"</string>
    <string name="title_regional_pref_footer" msgid="7450438024324794380">"Uma i-app ingakusekeli okuncanyelwayo kwesifunda, i-app izosebenzisa amasethingi ayo endawo azenzekelayo."</string>
    <string name="desc_regional_pref_footer_learn_more" msgid="4401708653329230081">"Funda kabanzi mayelana nokuncanyelwayo kolimi."</string>
    <string name="category_title_terms_of_address" msgid="4309422700380895278">"Izintandokazi ezengeziwe"</string>
    <string name="terms_of_address_title" msgid="4064593634733842458">"Imigomo yekheli"</string>
    <string name="terms_of_address_summary" msgid="6136134336560679144">"Setha indlela ofuna kukhulunywe nawe ngayo"</string>
    <string name="terms_of_address_intro_title" msgid="6149691509414243483">"Ama-app angasebenzisa imigomo yekheli lakho ukuze zenze kube ngokwakho ukuthi zikhuluma nawe kanjani."</string>
    <string name="terms_of_address_not_specified" msgid="4439257779351251973">"Akucacisiwe"</string>
    <string name="terms_of_address_feminine" msgid="1743479869695539283">"Okwabesifazane"</string>
    <string name="terms_of_address_masculine" msgid="983106046135098856">"Okwabesilisa"</string>
    <string name="terms_of_address_neutral" msgid="5475414185543112478">"Maphakathi nendawo"</string>
    <string name="dlg_remove_locales_title" msgid="3170501604483612114">"{count,plural, =1{Sula ulimi olukhethiwe?}one{Sula izilimi ezikhethiwe?}other{Sula izilimi ezikhethiwe?}}"</string>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Umbhalo uzoboniswa ngolunye ulimi."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Ayikwazi ukususa zonke izilimi"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Gcina okungenani ulimi olulodwa oluncanyelwayo"</string>
    <string name="locale_not_translated" msgid="3071618135527110152">"Akutholakali njengolimi lwesistimu"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Iya phezulu"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Iya phansi"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Thumela Phezulu"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Isa phansi"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Susa ulimi"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Khetha okwenziwayo"</string>
    <string name="cancel" msgid="5780102414089664898">"Khansela"</string>
    <string name="okay" msgid="4827099303045669054">"KULUNGILE"</string>
    <string name="forget" msgid="3754013654135912783">"Khohlwa"</string>
    <string name="save" msgid="3125033126936493822">"Londoloza"</string>
    <string name="done" msgid="7497982645646431310">"Kwenziwe"</string>
    <string name="apply" msgid="7834684883190163536">"Faka"</string>
    <string name="share" msgid="8502235338607613795">"Yabelana"</string>
    <string name="add" msgid="8335206931421683426">"Engeza"</string>
    <string name="remove" msgid="1028414219245072102">"Susa"</string>
    <string name="settings_label" msgid="943294133671632976">"Izilungiselelo"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Izilungiselelo"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Isinqamuleli sezilungiselelo"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Imodi yendiza"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Amanethiwekhi; nokungenantambo"</string>
    <string name="roaming" msgid="3055365654530847985">"Iyazulazula"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Xhuma emasevisini edatha lapho uzulazula"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Xhuma kumasevisi edatha lapho uzulazula"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Izindleko zokuzula zingahle zisebenze."</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Setha isikhathi ngokuzenzekelayo"</string>
    <string name="zone_auto_title" msgid="5141692422373097957">"Setha ngokuzenzekelayo"</string>
    <string name="auto_zone_requires_location_summary" msgid="4831038184260596735">"Indawo izosetshenziselwa ukusetha izoni yesikhathi lapho lokhu kuguqulwa kuvuliwe"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Sebenzisa okuzenzakalelayo kwasendaweni"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"Sebenzisa ifomethi ye-24 amahora"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Isikhathi"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Ifomethi yesikhathi"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Indawo yesikhathi"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Khetha umkhawulo wesikhathi"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Idethi"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Sesha isifunda"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Isifunda"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"Khetha i-UTC offset"</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">"Isebenzisa i-<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> iqala ngo-<xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8399585343328811158">"Isebenzisa i-<xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Asikho isikhathi sokulondoloza sosuku."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Isikhathi sokulondoloza usuku"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Isikhathi esivamile"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Khetha ngesiyingi"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Kukhethwe i-UTC offset"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Khiya ngemuva kokuba isikrini siphelelwa yisikhathi"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> ngemuva kokuphela kwesikhathi"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Ngokushesha ngemuva kokuphela kwesikhathi, ngaphandle lapho uma ishiywa ingakhiyiwe nge-<xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="3441806647509073124">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> ngemva kokuphela kwesikhathi, ngaphandle kokugcina ivuliwe yi-<xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g>"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Engeza umbhalo kusikrini sokukhiya"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Lutho"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"Isb. I-Android ka-Joe."</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Indawo"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Sebenzisa indawo"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Valiwe"</string>
    <string name="location_settings_summary_location_on" msgid="4273299717586679786">"{count,plural, =1{Ivuliwe / i-app e-# enokufinyelela endaweni}one{Ivuliwe / ama-app angu-# anokufinyelela endaweni}other{Ivuliwe / ama-app angu-# anokufinyelela endaweni}}"</string>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Iyalayisha…"</string>
    <string name="location_settings_footer_general" msgid="1040507068701188821">"Ama-app anemvume Yamadivayisi aeseduze angakhetha indawo ehambelanayo yamadivayisi axhunyiwe."</string>
    <string name="location_settings_footer_location_off" msgid="8568995909147566720">"Ukufinyelela kwendawo kuvaliwe mayelana nama-app namasevisi. Indawo yedivayisi yakho isengathunyelwa kubaphenduli besimo esiphuthumayo uma ushaya ikholi noma uthumela umbhalo kwinombolo ephuthumayo."</string>
    <string name="location_settings_footer_learn_more_content_description" msgid="349380666660145540">"Funda kabanzi Ngamasethingi wendawo"</string>
    <string name="location_settings_tooltip_text_for_chrome" msgid="3574930966097093550">"Ukuze ushintshe ukufinyelela kwendawo, iya kokuthi Amasethingi Nokuvikeleka kanye Nobumfihlo Nezilawuli zokwemfihlo"</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Ama-akhawunti"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Ukuphepha"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Ukubethela nokuqinisekisa"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Khiya isikrini"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Yini engaboniswa"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Ayitholakali"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Isimo sokuphepha"</string>
    <string name="security_dashboard_summary" msgid="7571035662779425918">"Ukukhiya isikrini, Thola idivayisi yami, ukuphepha kwe-app"</string>
    <string name="safety_center_title" msgid="7732397372178774777">"Ukuphepha nobumfihlo"</string>
    <string name="safety_center_summary" msgid="3554867379951053869">"Ukuvikeleka kwe-app, ukukhiya idivayisi, izimvume"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Ubuso bungeziwe"</string>
    <string name="security_settings_face_preference_summary_none" msgid="523320857738436024">"Ukusetha kuyadingeka"</string>
    <string name="security_settings_face_preference_title" msgid="2126625155005348417">"Ukuvula ngobuso"</string>
    <string name="security_settings_face_profile_preference_title" msgid="7519527436266375005">"Ukuvula ngobuso komsebenzi"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6448806884597691208">"Indlela yokusetha Ukuvula ngobuso"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="3701874093226957891">"Setha Ukuvula ngobuso"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Sebenzisa ubuso bakho ukuze ufakazele ubuqiniso"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Qala"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="2965952386172202665">"Uma Ukuvula ngobuso kokufinyelela kuvaliwe, ezinye izinyathelo zokusetha zingase zingasebenzi kahle nge-TalkBack."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Iya emuva"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Qhubeka nokusetha"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Sebenzisa ukusetha kokufinyelela"</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">"Khansela"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Cha ngiyabonga"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"Ngiyavuma"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Okuningi"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Vula ngobuso bakho"</string>
    <string name="security_settings_face_enroll_consent_introduction_title" msgid="3942331854413767814">"Vumela i-face unlock"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Sebenzisa ubuso bakho ukuze ufakazele ubuqiniso"</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Sebenzisa ubuso bakho ukuze uvule ifoni yakho noma uvumele ukuthengwa.\n\nQaphela: Awukwazi ukusebenzisa ifoni yakho ukuze uvule le divayisi. Ukuze uthole olunye ulwazi, xhumana nomphathi wenhlangano yakho."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Sebenzisa ubuso bakho ukuze uvule ifoni yakho, ugunyaze ukuthenga, noma ungene ngemvume kuzinhlelo zokusebenza"</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">"Faka phakathi kwendawo ubuso bakho kundingiliza"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Yeqa"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Ungene inombolo enkulu yobuso"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"Ayikwazi ukungeza ubuso obuningi"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"Ukubhaliswa akuzange kuqedwe"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="1674650455786434426">"KULUNGILE"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="7768349698547951750">"Kufinyelelwe kumkhawulo wesikhathi sokubhaliswa kobuso. Zama futhi."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"Ukubhaliswa kobuso akuzange kusebenze."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Konke sokulungile. Kubukeka kukuhle."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Kwenziwe"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="6835778900387289683">"Thuthukisa ukusebenza Kokuvula ngobuso"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="7055780282999744813">"Setha Ukuvula ngobuso futhi"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="4421818770682557621">"Setha Ukuvula ngobuso futhi"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Thuthukisa ukuvikeleka nokusebenza"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="6194184776580066012">"Setha Ukuvula ngobuso"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="2670118180411127323">"Sula imodeli yakho yobuso yamanje ukusetha futhi Ukuvula ngobuso.\n\nImodeli yakho yobuso izosulwa ngunaphakade futhi ngokuvikelekile.\n\nNgemva kokusulwa, uzodinga Iphinikhodi, iphethini, noma iphasiwedi ukuvula ifoni yakho noma ukufakazela ubuqiniso kuma-app."</string>
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint" msgid="2469599074650327489">"Sula imodeli yakho yobuso yamanje ukusetha futhi Ukuvula ngobuso.\n\nImodeli yakho yobuso izosulwa ngunaphakade futhi ngokuvikelekile.\n\nNgemva kokusulwa, uzodinga izigxivizo zakho zeminwe, iphinikhodi, iphethini, noma iphasiwedi ukuvula ifoni yakho noma ukufakazela ubuqiniso kuma-app."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="1638314154119800188">"Sebenzisa Ukuvula ngobuso kwe-"</string>
    <string name="security_settings_face_settings_preferences_category" msgid="7628929873407280453">"Uma usebenzisa Ukuvula ngobuso"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Idinga amehlo ukuthi avulwe"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Ukuze uvule ifoni yakho, amehlo akho kumele avuleke"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Hlala ufuna ukuqinisekiswa"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="3498729789625461914">"Uma usebenzisa Ukuvula ngobuso kuma-app, hlala udinga isinyathelo sokuqinisekisa"</string>
    <string name="security_settings_face_settings_remove_face_model" msgid="812920481303980846">"Susa imodeli yobuso"</string>
    <string name="security_settings_face_settings_enroll" msgid="3726313826693825029">"Setha Ukuvula ngobuso"</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2899669764446232715">"Susa imodeli yobuso?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="916131485988121592">"Imodeli yakho yobuso izosulwa ingunaphakade nangokuphephile.\n\nNgemuva kokusulwa, uzodinga iphinikhodi yakho, iphethini, noma iphasiwedi ukuze uvule ifoni yakho noma ukufakazela ubuqiniso kuma-app."</string>
    <string name="security_settings_face_settings_remove_dialog_details_convenience" msgid="475568135197468990">"Imodeli yakho yobuso izosulwa ingunaphakade nangokuphephile.\n\nNgemuva kokusulwa, uzodinga iphinikhodi yakho, iphethini, noma iphasiwedi ukuze uvule ifoni yakho."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint" msgid="7609582230650860974">"Imodeli yobuso bakho izosulwa ngokuphelele nangokuphephile.\n\nNgemva kokusulwa, uzodinga isigxivizo somunwe, Iphinikhodi, iphethini, noma amaphasiwedi ukuvula ifoni yakho noma ukufakazelwa kobuqiniso kuma-app wakho."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint_conv" msgid="2627374706274503259">"Imodeli yakho yobuso izosulwa ingunaphakade nangokuphephile.\n\nNgemuva kokusulwa, uzodinga iphinikhodi yakho, iphethini, noma iphasiwedi ukuze uvule ifoni yakho."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="8284262560781442403">"Sebenzisa Ukuvula ngobuso ukuvula ifoni yakho"</string>
    <string name="security_settings_fingerprint" msgid="6387775386189204201">"Isigxivizo somunwe"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Izigxivizo zeminwe"</string>
    <string name="security_settings_fingerprint_settings_preferences_category" msgid="8975029409126780752">"Uma usebenzisa Ukuvula Ngesigxivizo Somunwe"</string>
    <string name="security_settings_work_fingerprint_preference_title" msgid="2076006873519745979">"Isigxivizo somunwe somsebenzi"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Engeza izigxivizo zeminwe"</string>
    <string name="security_settings_fingerprint_preference_summary" msgid="8486134175759676037">"{count,plural, =1{Isigxivizo somunwe singeziwe}one{Izigxivizo zeminwe ezingu-# zingeziwe}other{Izigxivizo zeminwe ezingu-# zingeziwe}}"</string>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1146977379031250790">"Ukusetha kuyadingeka"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="7931650601996313070">"Setha isigxivizo sakho somunwe"</string>
    <string name="security_settings_fingerprint_enroll_consent_introduction_title" msgid="2278592030102282364">"Vumela ukuvula ngesigxivizo somunwe"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Sebenzisa izigxivizo zeminwe zakho"</string>
    <string name="security_settings_fingerprint_settings_footer_learn_more" msgid="2508322993726483601">"Funda kabanzi mayelana Nokuvula Isigxivizo Somunwe"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_1" msgid="6808124116419325722">"Uwena olawulayo"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1" msgid="1122676690472680734">"Wena nengane yakho niyalawula"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2" msgid="5663733424583416266">"Cabanga njalo"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Sebenzisa isigxivizo zomunwe zakho ukuze uvule ifoni yakho noma uvume ukuthenga.\n\nInothi: Awukwazi ukusebenzisa isigxivizo somunwe ukuvula le divayisi. Ngolwazi olubanzi, xhumana nomlawuli wenhlangano yakho."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Khansela"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"Cha ngiyabonga"</string>
    <string name="security_settings_fingerprint_enroll_introduction_agree" msgid="4068276083536421828">"Ngiyavuma"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Yeqa izigxivizo zeminwe?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"Ukusethwa kwezigxivizo zeminwe kuthatha iminithi noma amabili kuphela. Uma weqa lokhu, ungangeza izigxivizo zakho zeminwe ngemuva kwesikhathi kuzilungiselelo."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_setup" msgid="6255210343107484206">"Uma ubona lolu phawu, sebenzisa izigxivizo zakho zeminwe ukuqinisekisa, njengalapho ungena ngemvume kuma-app noma uvumela ukuthengwa"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_1" msgid="4360262371633254407">"Khumbula"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2" msgid="2580899232734177771">"Indlela esebenza ngayo"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2" msgid="5909924864816776516">"Ukuvula Ngesigxivizo Seminwe kudala imodeli ehlukile yesigxivizo sakho seminwe ukuqinisekisa ukuthi nguwe. Ukuze kudalwe le modeli yesigxivizo seminwe ngesikhathi sokusethwa, uzothatha izithombe zesigxivizo sakho seminwe kusukela kuzimo ezihlukile."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2" msgid="3493356605815124807">"Ukuvula ngesigxivizo somunwe kudala imodeli ehlukile yesigxivizo seminwe sengane yakho ukuqinisekisa ukuthi iyona. Ukudala le modeli yesigxivizo seminwe ngesikhathi sokusetha, bazothatha izithombe zesigxivizo sabo seminwe kusukela kuzimo ezihlukile."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6" msgid="5314031490467481499">"Ukuze uthole imiphumela engcono, sebenzisa isivikeli sesikrini Esenzelwe I-Google esigunyaziwe. Kwezinye izivikeli zesikrini, isigxivizo sakho somunwe singase singasebenzi."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6" msgid="3563942520716110478">"Ukuze uthole imiphumela engcono, sebenzisa isivikeli sesikrini Esenzelwe I-Google esigunyaziwe. Kwezinye izivikeli zesikrini, isigxivizo somunwe wengane yakho ungase ungasebenzi."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_learn_more" msgid="5856010507790137793"></string>
    <string name="security_settings_activeunlock_preference_title" msgid="4257580421087062228">"Ukuvula Iwashi"</string>
    <string name="biometric_settings_intro_with_activeunlock" msgid="5032953826653108646">"Uma usetha i-Face Unlock ne-Fingerprint Unlock, ifoni yakho izokucela isigxivizo somunwe uma ugqoke isifonyo noma usendaweni engenako ukukhanya.\n\nI-Watch Unlock ingenye indlela elula yokuvula ifoni yakho, ngokwesibonelo, uma iminwe yakho imanzi noma ubuso bungaqashelwa."</string>
    <string name="biometric_settings_intro_with_fingerprint" msgid="5881355884547769337">"I-Watch Unlock ingenye indlela elula yokuvula ifoni yakho, ngokwesibonelo, uma isigxivizo sakho somunwe singaqashelwa."</string>
    <string name="biometric_settings_intro_with_face" msgid="7671919122230588521">"I-Watch Unlock ingenye indlela elula yokuvula ifoni yakho, ngokwesibonelo, uma ubuso bakho bungaqashelwa."</string>
    <string name="biometric_settings_use_fingerprint_or_watch_for" msgid="1160830065613858095">"Sebenzisa isigxivizo somunwe noma iwashi ukuze"</string>
    <string name="biometric_settings_use_face_or_watch_for" msgid="1507077107150278532">"Sebenzisa ubuso noma iwashi ukuze"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_for" msgid="7495835723072020641">"Sebenzisa ubuso, izigxivizo zeminwe, noma iwashi ukuze"</string>
    <string name="biometric_settings_use_watch_for" msgid="5454545622244040110">"Sebenzisa iwashi uku-"</string>
    <string name="biometric_settings_use_face_or_watch_preference_summary" msgid="4969685200340861744">"Ukusebenzisa ubuso noma iwashi"</string>
    <string name="biometric_settings_use_fingerprint_or_watch_preference_summary" msgid="2425628094194828407">"Ukusebenzisa isigxivizo somunwe noma iwashi"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary" msgid="188805113048792007">"Ukusebenzisa ubuso, isigxivizo somunwe, noma iwashi"</string>
    <string name="biometric_settings_use_watch_preference_summary" msgid="2311453276747908475">"Ukusebenzisa iwashi"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_title" msgid="8776904312629209685">"Setha Ukuvula Ngobuso noma Ngesigxivizo Somunwe kuqala"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_message" msgid="1669326067732567911">"Ungakwazi ukuvula ngewashi lakho uma ubuso bakho noma isigxivizo somunwe singaziwa"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_title" msgid="6703703635881050623">"Setha Ukuvula Ngesigxivizo Somunwe kuqala"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_message" msgid="4966813766409918392">"Ungakwazi ukuvula ngewashi lakho uma isigxivizo somunwe wakho singaziwa"</string>
    <string name="security_settings_activeunlock_require_face_setup_title" msgid="1428795376597739880">"Setha Ukuvula Ngobuso kuqala"</string>
    <string name="security_settings_activeunlock_require_face_setup_message" msgid="8904070645721933399">"Ungakwazi ukuvula ngewashi lakho uma ubuso bakho bungaziwa"</string>
    <string name="security_settings_activeunlock_biometric_setup" msgid="8876454457817955475">"Setha"</string>
    <string name="security_settings_fingerprint_single_watch_preference_summary" msgid="6464470096384164369">"Isigxivizo somunwe, ne-<xliff:g id="WATCH">%s</xliff:g> kungeziwe"</string>
    <string name="security_settings_fingerprint_multiple_watch_preference_summary" msgid="2259261786932097004">"Izigxivizo zomunwe, ne-<xliff:g id="WATCH">%s</xliff:g> kungeziwe"</string>
    <string name="security_settings_face_watch_preference_summary" msgid="5817376447253802793">"Ubuso ne-<xliff:g id="WATCH">%s</xliff:g> zingeziwe"</string>
    <string name="security_settings_fingerprint_single_face_watch_preference_summary" msgid="764951912234638192">"Ubuso, isigxivizo somunwe, ne-<xliff:g id="WATCH">%s</xliff:g> kungeziwe"</string>
    <string name="security_settings_fingerprint_multiple_face_watch_preference_summary" msgid="3935500711366489380">"Ubuso, izigxivizo zomunwe, ne-<xliff:g id="WATCH">%s</xliff:g> kungeziwe"</string>
    <string name="security_settings_remoteauth_preference_title" msgid="8319680328086089533">"Ukuvula Isiqinisekisi Serimothi"</string>
    <string name="security_settings_remoteauth_preference_summary" msgid="1507004469316635196">"Iwashi lifakiwe"</string>
    <string name="security_settings_remoteauth_enroll_introduction_title" msgid="2151004795778999671">"Setha iwashi lakho"</string>
    <string name="security_settings_remoteauth_enroll_introduction_message" msgid="8737276885766036074">"Ukuvula Iwashi kungenye indlela elula yokuvula le foni, ngokwesibonelo, uma iminwe yakho imanzi noma ubuso bungabonakali.\n\nUngasebenzisa iwashi lakho ukuze uvule le foni uma:"</string>
    <string name="security_settings_remoteauth_enroll_introduction_disagree" msgid="7639258097401796028">"Hhayi manje"</string>
    <string name="security_settings_remoteauth_enroll_introduction_agree" msgid="5271119227172049339">"Qhubeka"</string>
    <string name="security_settings_remoteauth_enroll_introduction_more" msgid="1644105894631257595">"Okwengeziwe"</string>
    <string name="security_settings_remoteauth_enroll_introduction_how_title" msgid="6604152528267830349">"Indlela esebenza ngayo"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_lock_open" msgid="8570511335628725116">"Iwashi lakho kufanele livulwe, esihlakaleni sakho, futhi ufinyeleleke kalula kule foni. Ngeke kudingeke ukuthi uvule iwashi lakho futhi lapho lisesihlakaleni sakho."</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_notifications" msgid="4298855831154039694">"Uma le foni ivuliwe, uzokwaziswa ewashini lakho. Uma beyivuliwe ngenkathi obungahlosile ngayo, thepha isaziso ukuze ukhiye ifoni futhi."</string>
    <string name="security_settings_remoteauth_enroll_introduction_youre_in_control_title" msgid="7974976673323638524">"Uwena olawulayo"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_remove_watch" msgid="1888318677088986801">"Ungasusa iwashi lakho kokuthi Ukuvula Iwashi nganoma yisiphi isikhathi Kumasethingi"</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_tap_notification" msgid="1597397399097952974">"Thepha isaziso"</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_swipe_up" msgid="2129230804324634653">"Swayipha phezulu esikrini sokukhiya"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_title" msgid="313016997943607675">"Khetha iwashi lakho"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_list_heading" msgid="8227585438932911013">"Amawashi atholakalayo"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_disagree" msgid="1670201454188049863">"Khansela"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_agree" msgid="7048336252635730908">"Qinisekisa"</string>
    <string name="security_settings_remoteauth_enroll_finish_title" msgid="3807372930755413112">"Usumi ngomumo!"</string>
    <string name="security_settings_remoteauth_enroll_finish_description" msgid="4876209907275244653">"Manje usungasebenzisa iwashi lakho ukuze uvule le foni uma uswayiphela phezulu esikrinini sokukhiya noma uthepha isaziso"</string>
    <string name="security_settings_remoteauth_enroll_finish_btn_next" msgid="8072138423143889592">"Kwenziwe"</string>
    <string name="security_settings_remoteauth_settings_title" msgid="1564912618737165129">"Ukuvula Iwashi"</string>
    <string name="security_settings_remoteauth_settings_description" msgid="2758239650119457964">"Ungasebenzisa iwashi lakho ukuze uvule le foni uma uswayiphela phezulu esikrinini sokukhiya noma uthephe isaziso"</string>
    <string name="security_settings_remoteauth_settings_info_footer" msgid="795894033901478120">"Ukuze usebenzise Ukuvula Iwashi, iwashi lakho kufanele livulwe, esandleni sakho, endaweni ongalifinyelela kuyo, futhi lixhunywe kule foni. Uma ukuxhuma kuphazamiseka, kuzodingeka uvule ifoni ngaphambi kokuba usebenzise okuthi Ukuvula Iwashi.\n\nKhumbula:\nUngaba newashi elilodwa kuphela elisethiwe ngesikhathi esisodwa. Ukuze ufake elinye iwashi, qala ngokususa elamanje."</string>
    <string name="security_settings_remoteauth_settings_learn_more" msgid="5653556124819260050">"Funda kabanzi mayelana Nokuvula Iwashi"</string>
    <string name="security_settings_remoteauth_settings_register_new_authenticator" msgid="9191331738306527887">"Faka iwashi"</string>
    <string name="security_settings_remoteauth_settings_remove_device" msgid="2436226120578851282">"Susa iwashi"</string>
    <string name="security_settings_biometric_preference_title" msgid="5012627247749093938">"Isigxivizo somunwe Nokuvula Ngobuso"</string>
    <string name="security_settings_work_biometric_preference_title" msgid="3121755615533533585">"Ukuvula Ngobuso Nangesigxivizo Somunwe emsebenzini"</string>
    <string name="security_settings_biometric_preference_summary_none_enrolled" msgid="213377753727694575">"Ukusetha kuyadingeka"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_multiple" msgid="4821859306609955966">"Ubuso nezigxivizo zeminwe kungeziwe"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_single" msgid="684409535278676426">"Ubuso nezigxivizo zeminwe zingeziwe"</string>
    <string name="biometric_settings_intro" msgid="4263069383955676756">"Uma usetha Ukuvula Ngobuso kanye Nokuvula Ngesigxivizo somunwe, ifoni yakho izocela isigxivizo somunwe uma ugqoke imaski noma usendaweni emnyama"</string>
    <string name="biometric_settings_category_ways_to_unlock" msgid="3384767901580915266">"Izindlela zokuvula"</string>
    <string name="biometric_settings_category_use_face_fingerprint" msgid="4377659744376863913">"Sebenbzisa ubuso noma isigxivizo somunwe uku"</string>
    <string name="biometric_settings_use_biometric_unlock_phone" msgid="8180914579885804358">"Vula ifoni yakho"</string>
    <string name="biometric_settings_use_biometric_for_apps" msgid="6201168728906364189">"Qinisekisa ukuthi kukuma-app wakho"</string>
    <string name="biometric_settings_use_face_preference_summary" msgid="1821648836899408477">"Ukusebenzisa ubuso"</string>
    <string name="biometric_settings_use_fingerprint_preference_summary" msgid="6077762097826050165">"Ukusebenzisa isigxiviso somunwe"</string>
    <string name="biometric_settings_use_face_or_fingerprint_preference_summary" msgid="3029102492674234728">"Uksuebenzisa ubuso noma isigxivizo somunwe"</string>
    <string name="biometric_settings_hand_back_to_guardian_ok" msgid="1763788801883247426">"KULUNGILE"</string>
    <string name="biometric_settings_add_face_in_split_mode_title" msgid="6041232223862753222">"Ayikwazi ukusetha Ukuvula ngobuso"</string>
    <string name="biometric_settings_add_face_in_split_mode_message" msgid="1904738532939614456">"Phuma esikrinini sokuhlukanisa ukuze usethe Ukuvula ngobuso"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_title" msgid="9194670722730454903">"Ayikwazi ukusetha isigxivizo somunwe"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_message" msgid="6960548382076629454">"Phuma esikrinini sokuhlukanisa ukuze usethe Ukuvula Ngesigxivizo Somunwe"</string>
    <string name="biometric_settings_add_biometrics_in_split_mode_ok" msgid="564103789097253645">"KULUNGILE"</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Yeqa ukukhiya isikrini?"</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Yeqa noma kunjalo"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Buyela emuva"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Yeqa"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Khansela"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Thinta inzwa"</string>
    <string name="security_settings_sfps_enroll_find_sensor_title" msgid="8327884364635804363">"Thinta inkinobho yamandla ngaphandle kokuyicindezela"</string>
    <string name="security_settings_udfps_enroll_find_sensor_title" msgid="8077484429913330179">"Indlela yokusetha izigxivizo zakho zeminwe"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"Kusemuva kwefoni yakho. Sebenzisa umunwe wakho wokukhomba."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="8383106460819519961">"Inzwa yesigxivizo seminwe isesikrinini sakho. Uzothatha izigxivizo zakho zeminwe kusikrini esilandelayo"</string>
    <string name="security_settings_udfps_enroll_find_sensor_start_button" msgid="3172268783620336357">"Qala"</string>
    <string name="security_settings_udfps_enroll_a11y" msgid="1899453114050362235">"Hambisa umunwe wakho esikrinini ukuze uthole inzwa. Thinta futhi ubambe inzwa yezigxivizo zeminwe."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Ukuvezwa ngedivayisi ngendawo yenzwa yezigxivizo zeminwe"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Igama"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"KULUNGILE"</string>
    <string name="security_settings_fingerprint_enroll_dialog_try_again" msgid="8117874972945407006">"Zama futhi"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Susa"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Thinta inzwa"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Beka umunwe wakho kunzwa uphinde uphakamise ngemuva kokuthi uzwe ukudlidliza"</string>
    <string name="security_settings_udfps_enroll_start_message" msgid="5032954588171487566">"Gcina isigxivizo somunwe wakho siphansi kunzwa kuze kube yilapho uzwa ukudlidliza"</string>
    <string name="security_settings_sfps_enroll_start_message" msgid="9054672627477685212">"Ngaphandle kokucindezela inkinobho, gcina isigxivizo somunwe wakho kunzwa uze uzwe ukudlidliza.\n\nHambisa umunwe wakho kancane isikhathi ngasinye. Lokhu kusiza ukuthatha iningi lesigxivizo sakho somunwe."</string>
    <string name="security_settings_fingerprint_enroll_udfps_title" msgid="6665610134560896895">"Thinta futhi ubambe inzwa yezigxivizo zeminwe"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Phakamisa, bese uthinte futhi"</string>
    <string name="security_settings_udfps_enroll_title_one_more_time" msgid="424937043843482410">"Kanye futhi"</string>
    <string name="security_settings_udfps_enroll_repeat_title_touch_icon" msgid="4096344864386190335">"Landela isithonjana sezigxivizo zeminwe"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Qhubeka nokuphakamisa umunwe wakho ukuze ungeze izingxenye ezahlukahlukene zezigxiviso zeminwe zakho"</string>
    <string name="security_settings_udfps_enroll_repeat_message" msgid="2213106975297867798">"Thinta uphinde ubambe isikhathi lapho isithonjana sesigxivizo somunwe sinyakaza khona. Lokhu kusiza ukuthatha iningi lesigxivizo sakho somunwe."</string>
    <string name="security_settings_udfps_enroll_fingertip_title" msgid="4123142574168831116">"Beka ithiphu yomunwe wakho kunzwa"</string>
    <string name="security_settings_udfps_enroll_left_edge_title" msgid="1944076382202470458">"Beka umkhawulo wesokunxele womunwe wakho"</string>
    <string name="security_settings_udfps_enroll_right_edge_title" msgid="9036744264606447490">"Beka umkhawulo wesokudla womunwe wakho"</string>
    <string name="security_settings_sfps_enroll_finger_center_title" msgid="1320688855767675739">"Beka ingxenye emaphakathi yomunwe wakho kunzwa"</string>
    <string name="security_settings_sfps_enroll_fingertip_title" msgid="2737520837684516446">"Beka ithiphu yomunwe wakho kunzwa"</string>
    <string name="security_settings_sfps_enroll_left_edge_title" msgid="9022963735924413343">"Beka unqenqema lomunwe wakho wangakwesobunxele kunzwa"</string>
    <string name="security_settings_sfps_enroll_right_edge_title" msgid="823106857743394392">"Ekugcineni, beka unqenqema lomunwe wakho ongakwesokudla kunzwa"</string>
    <string name="security_settings_udfps_enroll_edge_message" msgid="4455253923746607702">"Beka uhlangothi lwesigxivizo sakho somunwe kunzwa uphinde ubambe, bese ushintshela kolunye uhlangothi"</string>
    <string name="security_settings_udfps_enroll_repeat_a11y_message" msgid="2785464357615568197">"Lokhu kusiza ukuthatha iningi lwesigxivizo sakho somunwe"</string>
    <string name="security_settings_sfps_enroll_progress_a11y_message" msgid="6450772721691523736">"Iphesenti elingu-<xliff:g id="PERCENTAGE">%d</xliff:g> lokubhalisela isigxivizo somunwe"</string>
    <string name="security_settings_sfps_animation_a11y_label" msgid="8808819903730940446">"Kubhaliswe amaphesenti angu-<xliff:g id="PERCENTAGE">%d</xliff:g>"</string>
    <string name="security_settings_udfps_enroll_progress_a11y_message" msgid="6183535114682369699">"Iphesenti elingu-<xliff:g id="PERCENTAGE">%d</xliff:g> lokubhalisela izigxivizo zeminwe"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Izigxivizo zeminwe zingeziwe"</string>
    <string name="security_settings_require_screen_on_to_auth_title" msgid="1641621458536715518">"Thinta ukuze uvule noma kunini"</string>
    <string name="security_settings_require_screen_on_to_auth_description" msgid="4158414711168345398">"Thinta inzwa ukuze uvule, nanoma isikrini sivaliwe. Lokhu kwenza amathuba amaningi okuvula ngephutha."</string>
    <string name="security_settings_require_screen_on_to_auth_keywords" msgid="5557869560397089603">"Ukuvula, Isikrini"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Yenza kamuva"</string>
    <string name="security_settings_udfps_tip_fingerprint_help" msgid="7580784640741217494">"Phakamisa, bese uthinte futhi"</string>
    <string name="security_settings_udfps_side_fingerprint_help" msgid="2567232481013195191">"Beka uhlangothi lwesigxivizo sakho somunwe kunzwa uphinde ubambe, bese ushintshela kolunye uhlangothi"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"Yeqa ukusethwa kwezigxivizo zeminwe?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"Ukhethe ukusebenzisa izigxivizo zeminwe zakho njengendlela eyodwa yokuvula ifoni yakho. Uma weqa manje, kuzomele usethe lokhu ngemuva kwesikhathi. Ukusetha kuthatha iminithi noma isikhathi esingalapho."</string>
    <string name="lock_screen_skip_setup_title" msgid="6979006375138175111">"Yeqa ukusetha kwe-<xliff:g id="OPTIONS">%s</xliff:g>?"</string>
    <string name="lock_screen_pin_skip_title" msgid="6853866579893458111">"Yeqa ukusetha i-PIN?"</string>
    <string name="lock_screen_pin_skip_face_title" msgid="8810770395309512358">"Yeqa ukusetha kwephinikhodi nokobuso?"</string>
    <string name="lock_screen_pin_skip_fingerprint_title" msgid="371214283158750976">"Yeqa ukusetha kwephinikhodi nokwezigxivizo zeminwe?"</string>
    <string name="lock_screen_pin_skip_biometrics_title" msgid="1082066572914073311">"Yeqa ukusetha kwephinikhodi, kobuso, nokwezigxivizo zeminwe?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Yeqa ukusetha iphasiwedi?"</string>
    <string name="lock_screen_password_skip_face_title" msgid="8166210519462164998">"Yeqa ukusetha kwephasiwedi nobuso?"</string>
    <string name="lock_screen_password_skip_fingerprint_title" msgid="2506392546016772170">"Yeqa ukusetha kwephasiwedi nokwezigxivizo zeminwe?"</string>
    <string name="lock_screen_password_skip_biometrics_title" msgid="900281322095862009">"Yeqa ukusetha kwephasiwedi, kobuso, nokwezigxivizo zeminwe?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Yeqa ukusetha iphethini?"</string>
    <string name="lock_screen_pattern_skip_face_title" msgid="145100333454316334">"Yeqa ukusetha kwephethini, nokobuso?"</string>
    <string name="lock_screen_pattern_skip_fingerprint_title" msgid="2513110208722100495">"Yeqa ukusetha kwephethini nokwezigxivizo zeminwe?"</string>
    <string name="lock_screen_pattern_skip_biometrics_title" msgid="2434258106825380187">"Yeqa ukusetha kwephethini, kobuso, nokwezigxivizo zeminwe?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Hlela ukuvala isikrini"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Kwenziwe"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Hhayi bo, akuyona inzwa leyo"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Thinta inzwa emuva kwefoni yakho. Sebenzisa umunwe wakho wokukhomba."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_dialog_title" msgid="6305457126747942642">"Ayikwazi ukuqedela ukusethwa kwesigxivizo somunwe"</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message_setup" msgid="2735739618722623980">"Ungazama futhi manje noma usethe isigxivizo somunwe wakho ngokuhamba kwesikhathi Kumasethingi"</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message" msgid="5858386244898601003">"Ungazama futhi manje noma usethe isigxivizo somunwe wakho kamuva."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="8582267776559099046">"Ukusethwa kwesigxivizo somunwe kuphelelwe yisikhathi"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message_setup" msgid="8521566666541069383">"Ungasetha isigxivizo somunwe wakho kamuva Kumasethingi."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message_setup" msgid="8140162986046783546">"Kukhona okungahambanga kahle. Ungasetha isigxivizo somunwe wakho kamuva Kumasethingi."</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="3534341971920335247">"Ungasetha isigxivizo somunwe wakho kamuva."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="4344665784935791640">"Kukhona okungahambanga kahle. Ungasetha isigxivizo somunwe wakho kamuva."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Engeza enye"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Okulandelayo"</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_1" msgid="294529888220959309">"Inketho yokukhiya isikrini ikhutshaziwe. Ukuze ufunde kabanzi, xhumana nomphathi wenhlangano yakho."</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_2" msgid="8070829069640846543">"Usengakwazi nokusebenzisa isigxivizo somunwe wakho ukugunyaza okuthengwayo nokufinyelela ku-app."</string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Phakamisa umunwe, bese uphinda uthinta inzwa"</string>
    <string name="security_settings_fingerprint_bad_calibration_title" msgid="3073145395701953620">"Ayikwazi ukusebenzisa inzwa yesigxivizo somunwe"</string>
    <string name="security_settings_fingerprint_bad_calibration" msgid="304585658839584958">"Vakashela umhlinzeki wokulungisa."</string>
    <string name="security_advanced_settings" msgid="6260756619837834042">"Amasethingi wokuvikeleka amaningi"</string>
    <string name="security_advanced_settings_work_profile_settings_summary" msgid="7295451997961973175">"Ukukhiya iphrofayela yomsebenzi, ukubethela, nokuningi"</string>
    <string name="security_advanced_settings_no_work_profile_settings_summary" msgid="345336447137417638">"Ukubethela, izimfanelo, nokuningi"</string>
    <string name="security_advanced_settings_keywords" msgid="5294945170370974974">"ukuvikeleka, amasethingi wokuvikeleka amaningi, amasethingi amaningi, amasethingi wokuvikeleka athuthukisiwe"</string>
    <string name="privacy_advanced_settings" msgid="8828215456566937719">"Amasethingi obumfihlo engeziwe"</string>
    <string name="more_security_privacy_settings" msgid="123465614090328851">"Ukuvikeleka okwengeziwe nobumfihlo"</string>
    <string name="security_header" msgid="961514795852103424">"Ukuvikela"</string>
    <string name="privacy_header" msgid="5526002421324257007">"Ubumfihlo"</string>
    <string name="work_profile_category_header" msgid="85707750968948517">"Iphrofayela yomsebenzi"</string>
    <string name="private_space_title" msgid="1752064212078238723">"Isikhala esiyimfihlo"</string>
    <string name="private_space_summary" msgid="2274405892301976238">"Gcina ama-app angasese ekhiyiwe futhi efihliwe"</string>
    <string name="private_space_description" msgid="4059594203775816136">"Gcina ama-app agodliwe endaweni ehlukile ongayifihla noma uyikhiye"</string>
    <string name="private_space_lock_title" msgid="7230836881433350526">"Ukhiye wendawo engasese"</string>
    <string name="private_space_one_lock_summary" msgid="2106513606571219068">"Ungakwazi ukuvula isikhala esigodliwe ngendlela efanayo ovula ngayo idivayisi yakho, noma ukhethe ukhiye ohlukile"</string>
    <string name="private_space_screen_lock_title" msgid="8679383894967823163">"Sebenzisa ukukhiya isikrini sedivayisi"</string>
    <string name="private_space_biometric_title" msgid="3934339826674553174">"Ukuvula Ngobuso Nangesigxivizo Somunwe"</string>
    <string name="private_space_fingerprint_title" msgid="5989254643211889931">"Ukuvula Ngesigxivizo Somunwe"</string>
    <string name="private_space_face_title" msgid="3290402865367663079">"Ukuvula Ngobuso"</string>
    <string name="private_space_biometric_summary" msgid="4403837276018724581">"Thepha ukuze usethe"</string>
    <string name="private_space_fingerprint_unlock_title" msgid="3614016453395789051">"Ukuvula Ngesigxivizo Somunwe indawo engasese"</string>
    <string name="private_space_face_unlock_title" msgid="462248384776453613">"Ukuvula Ngobuso indawo engasese"</string>
    <string name="private_space_category_ways_to_unlock" msgid="4356631225316950046">"Izindlela zokuvula"</string>
    <string name="private_space_screen_lock_summary" msgid="394837965365561070">"Ifana nokukhiya isikrini sedivayisi"</string>
    <string name="private_space_new_lock_title" msgid="9056139964133004094">"Khetha isikhiya esisha wendawo engasese?"</string>
    <string name="private_space_auto_lock_title" msgid="8663409382910601261">"Khiya indawo engasese ngokuzenzekelayo"</string>
    <string name="private_space_auto_lock_page_summary" msgid="8679844515655838654">"Ungakhiya indawo yakho engasese ngokuzenzakalelayo uma ungakaze usebenzise idivayisi yakho okwesikhathi esithile"</string>
    <string name="private_space_auto_lock_every_time" msgid="1215061855836002830">"Njalo lapho idivayisi ikhiya"</string>
    <string name="private_space_auto_lock_after_inactivity" msgid="1748673030841528649">"Ngemva kwemizuzu engu-5 yokungenzi lutho"</string>
    <string name="private_space_auto_lock_never" msgid="595014527119778873">"Ungalokothi"</string>
    <string name="private_space_hide_title" msgid="8687034008994037610">"Fihla uma ikhiyiwe"</string>
    <string name="privatespace_hide_page_title" msgid="8417507414027827566">"Fihla indawo engasese uma ikhiyile"</string>
    <string name="privatespace_hide_page_summary" msgid="5525422595477989312">"Ukuze umise abanye abantu bazi ukuthi unesikhala esiyimfihlo kudivayisi yakho, ungasifihla ohlwini lwakho lwama-app"</string>
    <string name="privatespace_access_header" msgid="6066826215718835041">"Finyelela indawo engasese lapho ifihliwe"</string>
    <string name="privatespace_search_description" msgid="3121043205513022357">"Kusukela ohlwini lwakho lwama-app, faka \"indawo engasese\" kusikhala sokusesha"</string>
    <string name="privatespace_tap_tile_description" msgid="8346440188590931635">"Thepha isihloko sendawo engasese"</string>
    <string name="privatespace_unlock_description" msgid="3177710543121916413">"Vula indawo yakho engasese"</string>
    <string name="privatespace_hide_off_summary" msgid="7227778747159633671">"Valiwe"</string>
    <string name="privatespace_hide_on_summary" msgid="6136704537527640183">"Vuliwe"</string>
    <string name="private_space_category_system" msgid="1286843321867285700">"Isistimu"</string>
    <string name="private_space_delete_title" msgid="636873505724100006">"Sula indawo engasese"</string>
    <string name="private_space_delete_header" msgid="4594429153176776184">"Sula indawo engasese?"</string>
    <string name="private_space_delete_summary" msgid="3344372988408565545">"Indawo engasese izosuswa kudivayisi yakho. Wonke ama-app nedatha kuzosulwa. Awukwazi ukuhlehlisa lesi senzo."</string>
    <string name="private_space_accounts" msgid="1078277762792056395">"Ama-akhawunti alandelayo azosuswa endaweni yakho yangasese:"</string>
    <string name="private_space_delete_button_label" msgid="1256981385318225002">"Sula"</string>
    <string name="private_space_confirm_deletion_header" msgid="3468651585498942977">"Isula indawo engasese…"</string>
    <string name="private_space_confirm_deletion_summary" msgid="342544588554284686">"Lokhu kuzothatha izikhathi ezimbalwa"</string>
    <string name="private_space_deleted" msgid="7692240901492540053">"Indawo engasese isuliwe"</string>
    <string name="private_space_delete_failed" msgid="7705795653796174741">"Indawo engasese ayikwazanga ukusulwa"</string>
    <string name="private_space_unlocked" msgid="9091600948712932046">"Isikhala esiyimfihlo sivuliwe"</string>
    <string name="no_device_lock_title" msgid="1078223464721029954">"Setha ukukhiya isikrini"</string>
    <string name="no_device_lock_summary" msgid="7436025227616244687">"Ukuze usebenzise isikhala esigodliwe, setha ukukhiya kwesikrini kule divayisi."</string>
    <string name="no_device_lock_action_label" msgid="2640487005629001288">"Setha ukukhiya isikrini"</string>
    <string name="no_device_lock_cancel" msgid="4412602160321228863">"Khansela"</string>
    <string name="private_space_cancel_label" msgid="379259667396956886">"Khansela"</string>
    <string name="private_space_setup_button_label" msgid="2094882154623560585">"Setha"</string>
    <string name="private_space_setup_title" msgid="2272968244329821450">"Isikhala esiyimfihlo"</string>
    <string name="private_space_hide_apps_summary" msgid="4418722947376042418">"Fihla noma ukhiye ama-app agodliwe endaweni ehlukile. Sebenzisa i-Google Account eqondile ukuze uthole ukuvikeleka okwengeziwe."</string>
    <string name="private_space_setup_sub_header" msgid="5454598292017819146">"Setha indawo engasese"</string>
    <string name="private_space_separate_account_text" msgid="4492251315012955548"><b>"Khetha i-Google Account yesikhala sakho"</b>\n"Ukusebenzisa i-akhawunti eqondile kusiza ekuvimbeni amafayela avumelanisiwe, izithombe kanye nama-imeyili ukuba kuvele ngaphandle kwesikhala sakho"</string>
    <string name="private_space_protected_lock_text" msgid="9123250938334372735"><b>"Setha ukhiye"</b>\n"Khiya indawo yakho ukuze uvimbele abanye abantu ekuyivuleni"</string>
    <string name="private_space_install_apps_text" msgid="5693139160766464498"><b>"Faka ama-app"</b>\n"Indawo yakho engasese ine-Play Store yayo ukuze ukwazi ukufaka ama-app kalula."</string>
    <string name="private_space_apps_permission_text" msgid="7030946025253366172">"Ama-app asesikhaleni sakho esigodliwe ngeke avele kumphathi wemvume, kudeshibhodi yobumfihlo, namanye amasethingi uma isikhala sakho esiyimfihlo sikhiyiwe.\n\nIsikhala sakho esigodliwe asikwazi ukuhanjiswa siye kudivayisi entsha. Uzodinga ukumisa esinye isikhala esigodliwe uma ufuna ukusisebenzisa kwenye idivayisi.\n\nNoma ngubani oxhuma idivayisi yakho kukhompyutha noma ofaka ama-appa ayingozi kudivayisi yakho angakwazi ukufinyelela esikhaleni sakho esigodliwe."</string>
    <string name="private_space_setting_up_text" msgid="8458035555212009528">"Isetha isikhala esigodliwe…"</string>
    <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Izaziso ezivela kuma-app wendawo engasese ziyafihlwa uma ikhiyiwe"</string>
    <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Hlola amasethingi endawo engasese ukuze ufihle indawo engasese futhi usethe ukukhiya ngokuzenzakalelayo"</string>
    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
    <skip />
    <string name="private_space_error_screen_title" msgid="739381738044418346">"Ayikwazanga ukusetha indawo engasese"</string>
    <string name="private_space_tryagain_label" msgid="8305362615231738367">"Zama Futhi"</string>
    <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Sebenzisa ukukhiya isikrini ukuvula isikhala esigodliwe?"</string>
    <string name="private_space_lockscreen_summary" msgid="430569465080645805">"Ungakwazi ukuvula isikhala esigodliwe ngendlela efanayo ovula ngayo idivayisi yakho, noma ukhethe ukhiye ohlukile"</string>
    <string name="private_space_use_screenlock_label" msgid="9182153443192032782">"Sebenzisa ukukhiya isikrini"</string>
    <string name="private_space_set_lock_label" msgid="1790408277477408475">"Khetha ukhiya omusha"</string>
    <string name="private_space_success_title" msgid="4351904015352046118">"Usulungile!"</string>
    <string name="private_space_access_text" msgid="4433988836344567888">"Ukuze uthole isikhala sakho esiyimfihlo, iya ohlwini lwama-app akho bese uskrolela phansi"</string>
    <string name="private_space_done_label" msgid="1020482651595246071">"Kwenziwe"</string>
    <string name="private_space_scrolldown_to_access" msgid="4820954877349434545">"Skrolela phansi ukuze uthole indawo eyimfihlo"</string>
    <string name="private_space_retry_signin_title" msgid="8090276618867918844">"Ngena ngemvume"</string>
    <string name="private_space_retry_summary" msgid="1920444015972648774">"Ngena ngemvume ku-akhawunti ukuze usebenzise indawo engasese yakho"</string>
    <string name="private_space_skip_login_label" msgid="7078019409056628192">"Hhayi manje"</string>
    <string name="private_space_continue_login_label" msgid="7779965766333065391">"Qhubeka"</string>
    <string name="private_space_lock_setup_title" msgid="6541564212199510787">"Khetha ukhiye wesikhala sakho esigodliwe"</string>
    <string name="private_space_lock_setup_description" msgid="423405593476300918">"Ungakwazi ukuvula isikhala sakho esigodliwe usebenzisa isigxivizo somunwe sakho. Mayelana nokuvikeleka, lokhu okukhethwa kukho kudinga ukukhiya okuyisipele."</string>
    <string name="private_space_choose_your_pin_header" msgid="4560802934975898265">"Setha i-PIN yakho yendawo yangasese"</string>
    <string name="private_space_choose_your_password_header" msgid="7660259341095044434">"Setha iphasiwedi yendawo yangasese"</string>
    <string name="private_space_choose_your_pattern_header" msgid="2165607102459936724">"Setha iphethini yendawo yangasese"</string>
    <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Ama-app nezaziso"</string>
    <string name="private_space_notifications_title" msgid="3456249671149740404">"Izaziso ezizwelayo kusikrini sokukhiya"</string>
    <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Bonisa okuqukethwe okubucayi uma indawo engasese ivuliwe"</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">"Ungangeza izigxivizo zeminwe ezingafika kwezingu-<xliff:g id="COUNT">%d</xliff:g>"</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Ungeze inombolo ephezulu yezigxivizo zeminwe"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Ayikwazi ukwengeza izingxovizo zeminwe eziningi"</string>
    <string name="fingerprint_delete_title" msgid="5412123164503407098">"Sula i-\'<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>\'"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="4104208067277655068">"Ngeke ukwazi ukusebenzisa isigxivizo sakho seminwe ukuze uvule iphrofayela yakho yomsebenzi, ugunyaze ukuthenga, noma ungene ngemvume kuma-app omsebenzi."</string>
    <string name="encryption_settings_title" msgid="2848716008695618360">"Ukubethelwa"</string>
    <string name="encrypted_summary" msgid="545623487587251207">"Betheliwe"</string>
    <string name="no_screen_lock_issue_title" msgid="1814109590692792891">"Setha ukukhiya isikrini"</string>
    <string name="no_screen_lock_issue_summary" msgid="2383217853510608406">"Ukuthola ukuvikeleka okwengeziwe, setha Iphinikhodi, iphethini, noma iphasiwedi yale divayisi."</string>
    <string name="no_screen_lock_issue_action_label" msgid="2691229130486382863">"Setha ukukhiya isikrini"</string>
    <string name="no_screen_lock_issue_notification_title" msgid="1214876733592830628">"Setha ukukhiya isikrini"</string>
    <string name="no_screen_lock_issue_notification_text" msgid="8696194459170873345">"Ukuthola ukuvikeleka okwengeziwe, setha Iphinikhodi, iphethini, noma iphasiwedi yale divayisi."</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Vikela ifoni yakho"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Engeza izigxivizo zomunwe ukuze uvule"</string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Khetha isivali sesikrini"</string>
    <string name="lock_settings_picker_new_lock_title" msgid="3113042086804290919">"Khetha ukukhiya isikrini"</string>
    <string name="lock_settings_picker_update_lock_title" msgid="536853138943415927">"Khetha ukukhiya isikrini okusha"</string>
    <string name="lock_settings_picker_new_profile_lock_title" msgid="2270462215256413800">"Khetha ukhiye wama-app omsebenzi"</string>
    <string name="lock_settings_picker_update_profile_lock_title" msgid="5929068163516308927">"Khetha ukhiye wokusebenza omusha"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Ngokuvikelwa okungeziwe, setha ukukhiya isikrini kwesipele"</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Khetha indlela yokukhiya isikrini yakho eyikhophi yasenqolobaneni"</string>
    <string name="lock_settings_picker_admin_restricted_personal_message" msgid="3532653662159888328">"Uma ukhohlwa ukukhiya kwakho isikrini, umphathi wakho we-IT akakwazi ukukusetha kabusha."</string>
    <string name="lock_settings_picker_admin_restricted_personal_message_action" msgid="5956615234246626264">"Setha ukukhiya okuhlukile kokusebenza"</string>
    <string name="lock_settings_picker_profile_message" msgid="9142379549980873478">"Uma ukhohlwa lo khiye, cela umphathi wakho we-IT akusethele wona kabusha"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Izinketho zokukhiya isikrini"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Izinketho zokukhiya isikrini"</string>
    <string name="lock_screen_auto_pin_confirm_title" msgid="3012128112186088375">"Qinisekisa ngokuzenzakalelayo ukuvula"</string>
    <string name="lock_screen_auto_pin_confirm_summary" msgid="9050818870806580819">"Vula ngokuzenzakalelayo uma ufaka iphinikhodi efanele enamadijithi ayi-6 noma ngaphezulu. Lokhu kuvikeleke kancane kunokuthepha u-Enter ukuze uqinisekise."</string>
    <string name="auto_pin_confirm_user_message" msgid="6194556173488939314">"Qinisekisa ngokuzenzakalelayo Iphinikhodi elungile"</string>
    <string name="auto_pin_confirm_opt_in_security_message" msgid="580773976736184893">"Ukuqinisekisa Iphinikhodi yakho ngokuthepha u-Enter kuphephe kakhulu kunokusebenzisa ukuqinisekisa okuzenzakalelayo"</string>
    <string name="auto_confirm_on_pin_verify_description" msgid="2052240431173223502">"Faka iphinikhodi yedivayisi ukuze unike amandla ukuqinisekisa okuzenzakalelayo"</string>
    <string name="auto_confirm_off_pin_verify_description" msgid="4256219155659760047">"Faka Iphinikhodi yedivayisi ukuze ukhubaze ukuqinisekisa okuzenzakalelayo"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Isikrini sivaliwe."</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Ukukhiya iphrofayela yomsebenzi"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Lutho"</string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Swayipha"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Iphathini"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"i-PIN"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Iphasiwedi"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Hhayi manje"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Ukukhiya isikrini kwamanje"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="2229689425933043901">"Iphethini • Isigxivizo somunwe"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="7979848492740627674">"Iphinikhodi • Isigxivizo somunwe"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="6207676267295036963">"Iphasiwedi • Isigxivizo somunwe"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Qhubeka ngaphandle kwezigxivizo zeminwe"</string>
    <string name="face_unlock_set_unlock_pattern" msgid="4206669838203096608">"Iphethingi • Ubuso"</string>
    <string name="face_unlock_set_unlock_pin" msgid="9034912683791069602">"Iphinikhodi • Ubuso"</string>
    <string name="face_unlock_set_unlock_password" msgid="5874950853246424756">"Iphasiwedi • Ubuso"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Qhubeka ngaphandle Kokuvula ngobuso"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7399882488272450182">"Qhubeka ngaphandle kwesigxivizo sominwe noma ubuso"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Lutho"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Swayipha"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Iphathini"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Iphasiwedi"</string>
    <string name="unlock_disable_frp_warning_title" msgid="2545569051372893686">"Susa zonke izinhlobo zokuvula idivayisi?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"Susa ukuvikelwa kwedatha yephrofayela?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="6246242612158828147">"Iphethini ivikela ifoni yakho uma ilahlekile noma intshontshiwe"</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2259825377085781801">"Iphethini ivikela ifoni yakho uma ilahlekile noma intshontshiwe.<xliff:g id="EMPTY_LINE">

</xliff:g>Lokhu kusula nemodeli yesigxivizo somunwe egcinwe kudivayisi yakho. Ngeke ukwazi ukusebenzisa izigxivizo zakho zeminwe ekufakazeleni ubuqiniso kuma-app."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face" msgid="4699508435412336378">"Iphethini ivikela ifoni yakho uma ilahlekile noma intshontshiwe.<xliff:g id="EMPTY_LINE">

</xliff:g>Imodeli yakho yobuso nayo izosuswa unomphela futhi ngokuphephile. Ngeke ukwazi ukusebenzisa ubuso bakho ukufakazela ubuqinisio kuma-app."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face_fingerprint" msgid="7049706229344804972">"Iphethini ivikela ifoni yakho uma ilahlekile noma intshontshiwe.<xliff:g id="EMPTY_LINE">

</xliff:g>Lokhu kusula imodeli yesigxivizo somunwe egcinwe kudivayisi yakho. Imodeli yakho yobuso nayo izosulwa ingunaphakade futhi ngokuphephile. Ngeke uze ukwazi ukusebenzisa ubuso bakho noma izigxivizo zeminwe ukufakazela ubuqiniso kuma-app."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="122154942944422284">"Iphinikhodi ivikela ifoni yakho uma ilahlekile noma intshontshiwe"</string>
    <string name="unlock_disable_frp_warning_content_pin_authbound_keys" msgid="6497861740382402784">"Uzolahlekelwa yidatha elondoloziwe Njengephinikhodi yakho.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Amakhadi asethelwe ukukhokha ngaphandle kokuthinta azosuswa.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Ama-wallet namanye ama-app adinga ukuvulwa kwedivayisi angase angasebenzi kahle."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="983373874470746066">"Iphinikhodi ivikela ifoni yakho uma ilahlekile noma intshontshiwe.<xliff:g id="EMPTY_LINE">

</xliff:g>Lokhu kusula nemodeli yezigxivizo zeminwe ezigcinwe kudivayisi yakho. Ngeke ukwazi ukusebenzisa izigxivizo zakho zeminwe ekufakazeleni ubuqiniso kuma-app."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint_authbound_keys" msgid="8930057076658360799">"Uzolahlekelwa yidatha elondoloziwe Njengephinikhodi yakho nesigxivizo somunwe.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Amakhadi asethelwe ukukhokha ngaphandle kokuthinta azosuswa.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Ama-wallet namanye ama-app adinga ukuvulwa kwedivayisi angase angasebenzi kahle."</string>
    <string name="unlock_disable_frp_warning_content_pin_face" msgid="5607150515413131761">"Iphinikhodi ivikela ifoni yakho uma ilahlekile noma intshontshiwe.<xliff:g id="EMPTY_LINE">

</xliff:g>Imodeli yakho yobuso nayo izosuswa unomphela futhi ngokuphephile. Ngeke ukwazi ukusebenzisa ubuso bakho ukufakazela ubuqinisio kuma-app."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_authbound_keys" msgid="979399855891561038">"Uzolahlekelwa idatha elondoloziwe Njengephinikhodi yakho nemodeli yobuso.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Amakhadi asethelwe ukukhokha ngaphandle kokuthinta azosuswa.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Ama-wallet namanye ama-app adinga ukuvulwa kwedivayisi angase angasebenzi kahle."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint" msgid="1821792325159866312">"Iphinikhodi ivikela ifoni yakho uma ilahlekile noma intshontshiwe.<xliff:g id="EMPTY_LINE">

</xliff:g>Lokhu kusula imodeli yezigxivizo zeminwe ezigcinwe kudivayisi yakho. Imodeli yakho yobuso nayo izosulwa ingunaphakade futhi ngokuphephile. Ngeke uze ukwazi ukusebenzisa ubuso bakho noma izigxivizo zeminwe ukufakazela ubuqiniso kuma-app."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint_authbound_keys" msgid="7019955731206729909">"Uzolahlekelwa yidatha elondoloziwe Njengephinikhodi yakho, ubuso nesigxivizo somunwe.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Amakhadi asethelwe ukukhokha ngaphandle kokuthinta azosuswa.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Ama-wallet namanye ama-app adinga ukuvulwa kwedivayisi angase angasebenzi kahle."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="6422723907917376210">"Iphasiwedi ivikela ifoni yakho uma ilahlekile noma intshontshiwe"</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8899452884016354856">"Iphasiwedi ivikela ifoni yakho uma ilahlekile noma intshontshiwe.<xliff:g id="EMPTY_LINE">

</xliff:g>Lokhu kusula nemodeli yezigxivizo zeminwe ezigcinwe kudivayisi yakho. Ngeke ukwazi ukusebenzisa izigxivizo zakho zeminwe ekufakazeleni ubuqiniso kuma-app."</string>
    <string name="unlock_disable_frp_warning_content_password_face" msgid="1811067332335964495">"Iphasiwedi ivikela ifoni yakho uma ilahlekile noma intshontshiwe.<xliff:g id="EMPTY_LINE">

</xliff:g>Imodeli yakho yobuso nayo izosuswa unomphela futhi ngokuphephile. Ngeke ukwazi ukusebenzisa ubuso bakho ukufakazela ubuqinisio kuma-app."</string>
    <string name="unlock_disable_frp_warning_content_password_face_fingerprint" msgid="7063649456205159491">"Iphasiwedi ivikela ifoni yakho uma ilahlekile noma intshontshiwe.<xliff:g id="EMPTY_LINE">

</xliff:g>Lokhu kusula imodeli yezigxivizo zeminwe egcinwe kudivayisi yakho. Imodeli yakho yobuso nayo izosulwa ingunaphakade futhi ngokuphephile. Ngeke uze ukwazi ukusebenzisa ubuso bakho noma izigxivizo zeminwe ukufakazela ubuqiniso kuma-app."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Izici zokuvikela idivayisi ngeke zisebenze ngaphandle kokukhiya isikrini sakho."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="6542744110902941189">"Izakhi zokuvikela idivayisi ngeke zize zisebenze ngaphandle kokukhiya kwakho isikrini.<xliff:g id="EMPTY_LINE">

</xliff:g>Lokhu kuphinda kusule imodeli yezigxivizo zeminwe egcinwe kudivayisi yakho. Ngeke ukwazi ukusebenzisa izigxivizo zakho zeminwe ekufakazeleni ubuqiniso kuma-app."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face" msgid="4559917661432267841">"Izakhi zokuvikela idivayisi ngeke zisebenze ngaphandle kokukhiya kwakho isikrini.<xliff:g id="EMPTY_LINE">

</xliff:g>Imodeli yakho yobuso nayo izosulwa ingunaphakade futhi ngokuphephile. Ngeke ukwazi ukusebenzisa ubuso bakho ukufakazela ubuqinisio kuma-app."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face_fingerprint" msgid="3779582301453677644">"Izakho zokuvikela idivayisi ngeke zize zisebenze ngaphandle kokukhiya kwakho isikrini.<xliff:g id="EMPTY_LINE">

</xliff:g>Lokhu kusula imodeli yezigxivizo zeminwe kudivayisi yakho. Imodeli yakho yobuso nayo izosulwa ingunaphakade futhi ngokuphephile. Ngeke uze ukwazi ukusebenzisa ubuso bakho noma izigxivizo zeminwe ukufakazela ubuqiniso kuma-app."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="6173427638951230842">"Sula"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"I-<xliff:g id="APP_NAME">%1$s</xliff:g> incoma i-PIN eqinile noma iphasiwedi futhi kungenzeka ingasebenzi njengoba kulindelwe ngaphandle kweyodwa"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"I-<xliff:g id="APP_NAME">%1$s</xliff:g> incoma i-PIN entsha noma iphasiwedi futhi kungenzeka ingasebenzi njengoba kulindelwe ngaphandle kweyodwa"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"I-<xliff:g id="APP_NAME">%1$s</xliff:g> incoma iphethini entsha, i-PIN, noma iphasiwedi futhi kungenzeka ingasebenzi njengoba kulindelwe ngaphandle kweyodwa"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"I-<xliff:g id="APP_NAME">%1$s</xliff:g> incoma ukukhiya kwesikrini okusha"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"Zama futhi. Umzamo ongu-<xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g> kwengu-<xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="7450322567217745999">"Idatha yakho izosuswa"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"Uma ufaka iphethini engalungile kumzamo olandelayo, le datha yamadivayisi izosuswa"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"Uma ufaka iphinikhodi engalungile kumzamo olandelayo, le datha yalawa madivayisi izosuswa"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"Uma ufake iphasiwedi engalungile kumzamo olandelayo, le datha yalawa madivayisi izosuswa"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"Uma ufaka iphethini engalungile kumzamo olandelayo, lo msebenzisi uzosuswa"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"Uma ufaka iphinikhodi engalungile kumzamo olandelayo, lo msebenzisi uzosuswa"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"Uma ufaka iphasiwedi engalungile kumzamo olandelayo, lo msebenzisi uzosuswa"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"Uma ufaka iphethini engalungile kumzamo olandelayo, iphrofayela yakho yomsebenzi nedatha yayo izosuswa"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Uma ufaka iphinikhodi engalungile kumzamo olandelayo, iphrofayela yakho yomsebenzi nedatha yayo izosuswa"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Uma ufake iphasiwedi engalungile kumzamo olandelayo, iphrofayela yakho yomsebenzi nedatha yayo izosuswa"</string>
    <string name="lockpassword_password_too_short" msgid="1938086368137797700">"{count,plural, =1{Kufanele kuqukathe okungenani uhlamvu olu-#}one{Kumele okungenani ibe yizinhlamvu ezingu-#}other{Kumele okungenani ibe yizinhlamvu ezingu-#}}"</string>
    <string name="lockpassword_password_too_short_all_numeric" msgid="4301294924022401502">"{count,plural, =1{Uma usebenzisa izinombolo kuphela, kumelwe okungenani zibe idijithi engu-1}one{Uma usebenzisa izinombolo kuphela, kumelwe okungenani zibe amadijithi angu-#}other{Uma usebenzisa izinombolo kuphela, kumelwe okungenani zibe amadijithi angu-#}}"</string>
    <string name="lockpassword_pin_too_short" msgid="8910105226463085689">"{count,plural, =1{Iphinikhodi kufanele iqukathe idijithi okungenani e-#}one{Iphinikhodi kufanele ibe okungenani amadijithi angu-#}other{Iphinikhodi kufanele ibe okungenani amadijithi angu-#}}"</string>
    <string name="lockpassword_pin_too_short_autoConfirm_extra_message" msgid="3271351502900762571">"{count,plural, =1{Iphinikhodi kufanele iqukathe okungenani idijithi engu-#, kodwa i-Iphinikhodi enamadijithi angu-{minAutoConfirmLen} iyanconywa ukuze uvikeleke ngokwengeziwe}one{Iphinikhodi kufanele iqukathe okungenani amadijithi angu-#, kodwa i-Iphinikhodi enamadijithi angu-{minAutoConfirmLen} iyanconywa ukuze uvikeleke ngokwengeziwe}other{Iphinikhodi kufanele iqukathe okungenani amadijithi angu-#, kodwa i-Iphinikhodi enamadijithi angu-{minAutoConfirmLen} iyanconywa ukuze uvikeleke ngokwengeziwe}}"</string>
    <string name="lockpassword_password_too_long" msgid="1940345313260498308">"{count,plural, =1{Kufanele kube ngaphansi kohlamvu olu-#}one{Kufanele kube ngaphansi kwezinhlamvu ezingu-#}other{Kufanele kube ngaphansi kwezinhlamvu ezingu-#}}"</string>
    <string name="lockpassword_pin_too_long" msgid="1678212054564388576">"{count,plural, =1{Kufanele ibe ngaphansi kwedijithi eli-#}one{Kufanele ibe ngaphansi kwamadijithi angu-#}other{Kufanele ibe ngaphansi kwamadijithi angu-#}}"</string>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"Umlawuli wedivayisi akavumeli ukusebenzisa iphinikhodi yakamuva"</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"Lokhu akukwazi ukufana uhlamvu olungavumelekile"</string>
    <string name="lockpassword_password_requires_letters" msgid="7058340182953750553">"{count,plural, =1{Kufanele iqukathe okungenani uhlamvu olu-1}one{Kufanele okungenani iqukathe izinhlamvu ezingu-#}other{Kufanele okungenani iqukathe izinhlamvu ezingu-#}}"</string>
    <string name="lockpassword_password_requires_lowercase" msgid="3286121470522077547">"{count,plural, =1{Kufanele iqukathe okungenani uhlamvu oluncane olu-1}one{Kufanele iqukathe okungenani izinhlamvu ezincane ezingu-#}other{Kufanele iqukathe okungenani izinhlamvu ezincane ezingu-#}}"</string>
    <string name="lockpassword_password_requires_uppercase" msgid="720312543910397772">"{count,plural, =1{Kufanele iqukathe okungenani ufeleba o-1}one{Kufanele iqukathe okungenani ofeleba abangu-#}other{Kufanele iqukathe okungenani ofeleba abangu-#}}"</string>
    <string name="lockpassword_password_requires_numeric" msgid="3886918493600507548">"{count,plural, =1{Kufanele iqukathe okungenani idijithi eyinombolo e-1}one{Kufanele iqukathe okungenani amadijithi ayinombolo angu-#}other{Kufanele iqukathe okungenani amadijithi ayinombolo angu-#}}"</string>
    <string name="lockpassword_password_requires_symbols" msgid="2904870551002210131">"{count,plural, =1{Kufanele iqukathe okungenani isimbuli ekhethekile e-1}one{Kufanele iqukathe okungenani amasimbuli akhethekileangu-#}other{Kufanele iqukathe okungenani amasimbuli akhethekileangu-#}}"</string>
    <string name="lockpassword_password_requires_nonletter" msgid="1185342065898300006">"{count,plural, =1{Kufanele iqukathe okungenani oku-1 okungelona uhlamvu}one{Kufanele iqukathe okungenani okungu-# okungezona izinhlamvu}other{Kufanele iqukathe okungenani okungu-# okungezona izinhlamvu}}"</string>
    <string name="lockpassword_password_requires_nonnumerical" msgid="389687423482993365">"{count,plural, =1{Kumele iqukathe okungenani oku-1 okungeyona inhlamvu}one{Kumele iqukathe okungenani okungu-# okungezona izinhlamvu}other{Kumele iqukathe okungenani okungu-# okungezona izinhlamvu}}"</string>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"Umlawuli wedivayisi akavumeli ukusebenzisa iphasiwedi yakamuva"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Ukwenyuka, ukwehla, noma uchungechunge olwehlayo lamadijithi alivunyewe"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Qinisekisa"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Sula"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Ukukhiya isikrini besesivele sishintshiwe. Zama futhi ngokukhiya isikrini okusha."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Khansela"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Okulandelayo"</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Ama-app omlawuli wedivayisi"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"Awekho ama-app asebenzayo"</string>
    <string name="number_of_device_admins" msgid="3402909995362162876">"{count,plural, =1{I-app esebenzayo e-#}one{Ama-app asebenzayo angu-#}other{Ama-app asebenzayo angu-#}}"</string>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Abenzeli bethemba"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Ukuze usebenzise, qala ngokusetha ukukhiya kwesikrini"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Lutho"</string>
    <string name="manage_trust_agents_summary_on" msgid="3302574418419446146">"{count,plural, =1{Umenzeli o-1 othembekile osebenzayo}one{Abenzeli abangu-# abathembekile abasebenzayo}other{Abenzeli abangu-# abathembekile abasebenzayo}}"</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">"Bhangqa ne-<xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_group_late_bonding" msgid="3047893658902159692">"Qinisekisa ukuthi wengeza ingxenye yesibili yedivayisi yakho yokulalelwayo"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Ikhodi yokumatanisa ye-Bluetooth"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Thayipha ikhodi yokumatanisa bese ucindezela ku-Buyela noma ku-Enter"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"Iphinikhodi iqukethe amaletha namasimbui"</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Ngokuvamile 0000 noma 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Kumele ibe ngamadijithi angu-16"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Kungenzeka futhi udinge ukufaka le-PIN kwenye idivaysi."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Kungadingeka ufake lokhiye wokudlula kwenye idivayisi."</string>
    <string name="bluetooth_paring_group_msg" msgid="2455293929036668131">"Qiniseka ukuthi ubhangqa nedivayisi yokulalelwayo"</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Vumela ukufinyelela koxhumana nabo nomlando wekholi"</string>
    <string name="bluetooth_pairing_phonebook_toggle_text" msgid="2474015367387690034">"Phinda futhi uvumele ukufinyelela koxhumana nabo nomlando wekholi"</string>
    <string name="bluetooth_pairing_phonebook_toggle_details" msgid="1367197978487212581">"Ulwazi luzosetshenziselwa izimemezelo zekholi nokunye okwengeziwe"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Ayikwazanga ukuxhuma ku-<xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Amadivayisi atholakalayo"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Xhuma kwi-inthanethi"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Nqamula"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Bhangqa; uxhume"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="7326727272747345476">"Uma i-Bluetooth ivuliwe, idivayisi yakho ingakwazi ukuxhumana namanye amadivayisi aseduze we-Bluetooth"</string>
    <string name="bluetooth_empty_list_bluetooth_off_auto_on_available" msgid="5833847615853525971">"Uma i-Bluetooth ivuliwe, idivayisi yakho ingakwazi ukuxhumana namanye amadivayisi aseduze we-Bluetooth. Izakhi ezifana Nokwabelana Ngokushesha, okuthi Thola Idivayisi Yami, kanye nendawo yedivayisi zisebenzisa i-Bluetooth."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="786648535600075223">"Uma i-Bluetooth ivuliwe, idivayisi yakho ingaxhumana namanye amadivayisi e-Bluetooth aseduze.\n\nUkuze uthuthukise umuzwa wedivayisi, ama-app namasevisi asengaskena amadivayisi aseduze noma kunini, ngisho noma i-Bluetooth ivaliwe. Lokhu, ngokwesibonelo, kungasetshenziswa ukuthuthukisa izakhi namasevisi asuselwa endaweni. Ungakuguqula lokhu kumasethingi okuskena e-Bluetooth."</string>
    <string name="bluetooth_scanning_on_info_message_auto_on_available" msgid="5047787966768730069">"Uma i-Bluetooth ivuliwe, idivayisi yakho ingakwazi ukuxhumana namanye amadivayisi aseduze we-Bluetooth. Izakhi ezifana Nokwabelana Ngokushesha, Ukuthola Idivayisi Yami, nendawo yedivayisi sebenzisa i-Bluetooth.\n\nAma-app namasevisi asengaskenela amadivayisi aseduze noma kunini, nanoma i-Bluetooth ivaliwe. Lokhu kungasetshenziswa, njengesibonelo, ukuthuthukisa izakhi ezisuselwa kundawo namasevisi. Ungashintsha lokhu kumasethingi okuskena e-Bluetooth."</string>
    <string name="bluetooth_scan_change" msgid="1744636222637390367">"Shintsha"</string>
    <string name="device_details_title" msgid="1155622417516195481">"Imininingwane yedivayisi"</string>
    <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"Izilungiselelo zekhibhodi"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Ikheli le-Bluetooth yedivayisi: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_multuple_devices_mac_address" msgid="4974301550897923376">"Ikheli le-Bluetooth yedivayisi: \n<xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"Khohlwa idivayisi?"</string>
    <string name="remove_association_button" msgid="5004208145998061135">"Susa ukuhambisana"</string>
    <string name="bluetooth_companion_app_remove_association_dialog_title" msgid="1344518601377991897">"Nqamula i-App?"</string>
    <string name="bluetooth_companion_app_body" msgid="8442643629075687761">"I-app ye-<xliff:g id="APP_NAME">%1$s</xliff:g> ngeke isaxhumeka ku-<xliff:g id="DEVICE_NAME">%2$s</xliff:g> yakho"</string>
    <string name="device_details_leaudio_toggle_summary" msgid="7684848254433230809">"Okuhlolwayo Ithuthukisa ikhwalithi yomsindo."</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Khohlwa idivayisi"</string>
    <string name="bluetooth_companion_app_remove_association_confirm_button" msgid="76323555527926915">"Nqamula i-app"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Amadivayisi omsindo e-Bluetooth axhumekile"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Khetha inombolo enkulu yamadivayisi omsindo we-Bluetooth axhumekile"</string>
    <string name="nfc_stack_debuglog_title" msgid="2926748386805740609">"Ilogu yokususa iphutha lezitaki ze-NFC"</string>
    <string name="nfc_stack_debuglog_summary" msgid="7333205107551132121">"Khuphula ileveli yokungena yezitaki ze-NFC"</string>
    <string name="nfc_verbose_vendor_log_title" msgid="5554505631122964628">"Ilogu yokususa iphutha yomthengisi we-NFC verbose"</string>
    <string name="nfc_verbose_vendor_log_summary" msgid="3049128322855928507">"Faka phakathi amalogu angeziwe womthengisi wedivayisi ethile kwimibiko yeziphazamisi, angase abe nolwazi olugodliwe."</string>
    <string name="nfc_snoop_log_title" msgid="1576197495976952388">"Ilogu engahlungiwe ye-NFC NCI"</string>
    <string name="nfc_snoop_log_summary" msgid="3988383328800163180">"Thatha amaphakethe we-NFC aningiliziwe, angase abe nolwazi olugodliwe."</string>
    <string name="nfc_reboot_dialog_title" msgid="2033983438635768169">"Qalisa kabusha idivayisi?"</string>
    <string name="nfc_reboot_dialog_message" msgid="4929353168157966992">"Ukungena kwe-NFC okuningiliziwe kuhloselwe izinjongo zokuthuthukiswa kuphela. Idatha ye-NFC eyengeziwe ifakwe phakathi kwimibiko yeziphazamisi, engase ibe nolwazi olugodliwe. Qala kabusha idivayisi ukuze ushintshe le sethingi."</string>
    <string name="nfc_reboot_dialog_confirm" msgid="4769763632008584567">"Qala kabusha"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Abalingisi"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"isibuko"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Nika amandla ukubukeka okungenantambo "</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"Awekho amadivayisi aseduze atholakele."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Iyaxhuma"</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Ixhunyiwe"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"Kuyasebenza"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Ayitholakali"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Izinketho zokubonisa ezingenazintambo"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Khohlwa"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Kwenziwe"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Igama"</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">"Ngena ngemvume"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Vula isayithi"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"<xliff:g id="REMAINING_TIME">%1$s</xliff:g> esele"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Iphelelwa isikhathi ngomhla ka-<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> ifuna ukuvula i-Wi-Fi"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"<xliff:g id="REQUESTER">%s</xliff:g> ifuna ukuvala i-Wi-Fi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Qinisekisa i-bytecode yama-apps angalungiswa amaphutha"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Vumela i-ART ukuze iqinisekise i-bytecode yezinhlelo zokusebenza ezingasusa iphutha"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Bonisa isilinganiso sokuvuselela"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Bonisa isilinganisi sokuvuselela sesibonisi samanje"</string>
    <string name="show_hdr_sdr_ratio" msgid="4188007289024955585">"Bonisa isilinganiso se-HDR/SDR"</string>
    <string name="show_hdr_sdr_ratio_summary" msgid="986292785096013733">"Bonisa isilinganiso samanje se-HDR/SDR"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"i-NFC"</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Idinga ukuvula idivayisi ye-NFC"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"i-Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Ilungele ukudlulisa okuqukethwe uhlelo lokusebenza nge-NFC"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Valiwe"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Ayitholakali ngoba i-NFC icishiwe"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"Uma kuvulwe lesi sici, ungadlulisa okuqukethwe okusetshenziswayo kwenye ikhebuli ye-NFC ngokumisa amadivayisi enye eduze kwenye. Isibonelo ungahlanganisa amakhasi ewebhusayithi, amavidiyo e-YouTube, okuxhumana nabo, kanye nokunye.\n\nHlanganisa amadivayisi ndawonye (ngokujwayelekile enye ngemuva kwenye) bese uthepha isikrini sakho. Uhlelo lokusebenza luyathola ukuthi yini ezovumelaniswa."</string>
    <string name="wifi_settings" msgid="8313301946393559700">"I-Wi-Fi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"Sebenzisa i-Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"Izilungiselelo ze-Wi-Fi"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Khetha i-Wi-Fi"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"Ivula i-Wi-Fi..."</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"Ivala i-Wi-Fi..."</string>
    <string name="wifi_error" msgid="4903954145386086899">"Iphutha"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"5 GHz ibhendi ayitholakali kuleli zwe"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"Kwimodi yendiza"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Yazisa ngamanethiwekhi asesidlangalaleni"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Yazisa uma inethiwekhi yompahakthi enekhwalithi ephezulu itholakala"</string>
    <string name="wifi_allow_wep_networks" msgid="8772342993235292010">"Vumela amanethiwekhi e-WEP"</string>
    <string name="wifi_allow_wep_networks_summary" msgid="3033397893296724615">"I-WEP iyiphrothokholi yokuvikela endala engavikelekile"</string>
    <string name="wifi_allow_wep_networks_summary_carrier_not_allow" msgid="6298103289728210026">"Inkampani yakho yenethiwekhi ayiwavumeli amanethiwekhi e-WEP ngoba avikeleke kancane"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Vula i-Wi‑Fi ngokuzenzakalelayo"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"I-Wi‑Fi izovuleka eceleni kwamanethiwekhi alondolozwe ngekhwalithi ephezulu, njengenethiwekhi yakho yasekhaya"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Akutholakali ngoba indawo ivaliwe. Vula "<annotation id="link">"indawo"</annotation>"."</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Faka izitifiketi"</string>
    <string name="wifi_scan_notify_text" msgid="7163137260385995873">"Ukuze kuthuthukiswe ukunemba kwendawo, ama-app namasevisi asengaskena amanethiwekhi e-Wi-Fi noma kunini, nanoma i-Wi-Fi ivaliwe. Lokhu kungasetshenziselwa, njengesibonelo, ukuthuthukisa izici ezisuselwa endaweni namasevisi. Ungashintsha lokhu <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>kumasethingi okusena e-Wi-Fi<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="7439201783168213149">"Ukuze uthuthukise ukunemba kwendawo, vula ukuskena kwe-Wi-Fi <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>kumasethingi okuskena we-Wi-Fi<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Shintshela kudatha yeselula ngokuzenzakalela"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Sebenzisa idatha yeselula uma i-Wi-Fi ingenakho ukufinyelela kwe-inthanethi. Ukusetshenziswa kwedatha kungasebenza."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Yengeza inethiwekhi"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"Okuncamelayo kwe-Wi-Fi"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"I-Wi‑Fi ivuleka ngokuzenzakalelayo"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"I-Wi‑Fi ayivuli ngokuzenzakalelayo"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"I-Wi-Fi eqondile"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Ukubona amanethiwekhi atholakalayo, vula i-Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="2448010040478321376">"Iseshela amanethiwekhi…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Awunayo imvume yokushintsha inethiwekhi ye-Wi-Fi."</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Ivula ukuskena kwe-Wi‑Fi?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"Ukuze uvule i-Wi‑Fi ngokuzenzekelayo, kokuqala udinga ukuvula ukuskena kwe-Wi‑Fi."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"Ukuskena kwe-Wi-Fi kuvumela izinhlelo zokusebenza namasevisi ukuthi askenele amanethiwekhi e-Wi-Fi noma kunini, nanoma i-Wi-Fi ivaliwe. Lokhu kungasetshenziswa, njengesibonelo, ukuze kuthuthukiswe izici ezisuselwa endaweni namasevisi."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Vula"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"Ukuskena kwe-Wi-Fi kuvuliwe"</string>
    <string name="wifi_settings_warning_wep_network" msgid="2655077013800385646">"Le nethiwekhi isebenzisa iphrothokholi yokuvikela endala engavikeleke kancane"</string>
    <string name="wifi_settings_wep_networks_blocked_title" msgid="8337700496544833669">"I-<xliff:g id="NAME">%1$s</xliff:g> ivinjiwe"</string>
    <string name="wifi_settings_wep_networks_summary_toggle_off" msgid="1113138364046142949">"Le nethiwekhi isebenzisa iphrothokholi yokuvikela endala ebizwa nge-WEP, engavikelekile. Ukuze uxhume noma kunjalo, ungavumela amanethiwekhi e-WEP."</string>
    <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Inkampani yakho yenethiwekhi ayikuvumeli ukuthi uxhume kule nethiwekhi ngoba isebenzisa iphrothokholi yokuvikela endala engavikelekile"</string>
    <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Vumela i-WEP"</string>
    <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Vala"</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">"Izinketho ezithuthukile"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Izinketho ezithuthukisiwe zohlu olushona ezansi"</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"nweba"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Igama lenethiwekhi"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Faka i-SSID"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Ukuphepha"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Inethiwekhi efihliwe"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"Uma irutha yakho ingayisakazi i-ID yenethiwekhi kodwa ungathanda ukuxhumeka kuyo ngokuzayo, ungasetha inethiwekhi njengefihliwe.\n\nLokhu kungadala ingcuphe yezokuvikela ngoba ifoni yakho izosakaza ngokuvamile isignali yayo ukuze ithole inethiwekhi.\n\nUkusetha inethiwekhi njengefihliwe ngeke kushintshe izilungiselelo zerutha yakho."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Amandla esiginali"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Isimo"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Hambisa isivinini sesixhumanisi"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Thola isivinini sesixhumanisi"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Isivinini sokuhlanganisa"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Imvamisa"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"Ikheli le-IP"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Kulondolozwe nge-"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"<xliff:g id="NAME">%1$s</xliff:g> imininingwane yokungena"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"Indlela ye-EAP"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"Isigaba 2 sokuqinisekisa"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"Isitifiketi se-CA"</string>
    <string name="wifi_eap_min_tls_ver" msgid="174023604103299457">"Ubuncane bohlobo lwe-TLS"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Isimo sesitifiketi esiku-inthanethi"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Isizinda"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Isitifiketi somsebenzisi"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Ukuhlonza"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Ukuhlonza okungaziwe"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Iphasiwedi"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Bonisa iphasiwedi"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"2.4 GHz Ibhendi"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"5.0 GHz Band ekhethwayo"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"Izilungiselelo ze-IP"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Ubumfihlo"</string>
    <string name="wifi_privacy_mac_settings" msgid="3188060664478313363">"I-MAC"</string>
    <string name="wifi_privacy_device_name_settings" msgid="3699130177041345275">"Igama ledivaysi"</string>
    <string name="wifi_privacy_send_device_name_toggle_title" msgid="1228107313152880073">"Thumela igama ledivayisi"</string>
    <string name="wifi_privacy_send_device_name_toggle_summary" msgid="5995365836332817655">"Yabelana ngegama lale divayisi nenethiwekhi"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Okubhalisile"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Buka noma shintsha okubhalisile"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"I-MAC eyenziwe noma yini"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Engeza idivayisi"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Misa phakathi nendawo ikhodi ye-QR ngaphansi ukuze ungeze idivayisi ku-“<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"Skena ikhodi ye-QR"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Misa phakathi nendawo ikhodi ye-QR ngaphansi ukuze uxhumeke ku-“<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Joyina i-Wi‑Fi ngokuskena ikhodi ye-QR"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"Yaba i-Wi‑Fi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Skena le khodi ye-QR ngenye idivayisi ukuze ujoyine i-“<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Skena le khodi ye-QR ukuze ixhumeke ku-“<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Zama futhi. Uma inkinga iqhubeka, xhumana nomkhiqizi wedivayisi"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Okuthile akuhambanga kahle"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Yenza isiqinisekiso sokuthi idivayisi ixhunyiwe, ishajiwe, futhi ivuliwe"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Yenza isiqinisekiso sokuthi idivayisi ixhunyiwe, ishajiwe, futhi ivuliwe. Uma inkinga iqhubeka, xhumana nomkhiqizi wedivayisi"</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"Ukungeza i-“<xliff:g id="SSID">%1$s</xliff:g>” akusekelwa ile divayisi"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Zama ukuhambisa idivayisi eduze kwephoyinti lakho lokufinyelela/irutha ye-Wi-Fi"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Hlola iphasiwedi uphinde uzame futhi"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Xhumana nomkhiqizi wedivayisi"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Hlola ukuxhumeka uphinde uzame futhi"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Khetha inethiwekhi"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Ukuze uxhume idivayisi yakho, khetha inethiwekhi"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Engeza le divayisi ku-“<xliff:g id="SSID">%1$s</xliff:g>”?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"I-Wi-Fi yabiwe nedivayisi"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Engeza enye idivayisi"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Khetha inethiwekhi ehlukile"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Ayikwazanga ukungeza idivayisi"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Idivayisi itholiwe"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"Yabelana nge-Wi‑Fi ngale divayisi…"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Iyaxhuma…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Yabelana i-hotspot"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="5246641326066972419">"Qinisekisa ukuthi unguwe"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"Iphasiwedi ye-Wi‑Fi: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Iphasiwedi ye-hotspot: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Ukuxhumeka okuzenzakalelayo"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Vumela ukuxhumeka kule nethiwekhi uma ikubanga"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Engeza idivayisi"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Sebenzisa ikhodi ye-QR ukuze ungeze idivayisi kule nethiwekhi"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"Ikhodi ye-QR ayiyona ifomethi evumelekile"</string>
    <string name="retry" msgid="7542103800274026915">"Zama futhi"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Yabelana nabanye abasebenzisi bedivayisi"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(akushintshiwe)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Sicela ukhethe"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(Kungezwe izitifiketi eziningi)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Sebenzisa izitifiketi zesistimu"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Unganikezeli"</string>
    <string name="wifi_trust_on_first_use" msgid="7488431582505858774">"Ukwethemba Ekusetshenzisweni Kokuqala"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Igama lenethiwekhi lide kakhulu."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Kumele icacise isizinda."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Isitifiketi siyadingeka."</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"Ukuze kuthuthukiswe ukufaneleka kwendawo nezinye izinjongo, i-<xliff:g id="APP_NAME">%1$s</xliff:g> ifuna ukuvula ukuskena kwenethiwekhi, noma ngabe i-Wi-Fi ivaliwe.\n\nVumela lokhu ngazo zonke izinhlelo zokusebenza ezifuna ukuskena?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="4903345360745717385">"Ukuze uthuthukse ukunemba kwendawo nangezinye izinhloso, uhlelo lokusebenza olungaziwa lufuna ukuvula ukuskena inethiwekhi, ngisho noma i-Wi‑Fi ivaliwe.\n\nVumela lokhu kuzo zonke izinhlelo zokusebenza ezifuna ukuskena?"</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Vumela"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Phika"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Le nethiwekhi ayinakho ukufinyelela kwe-inthanethi. Hlala uxhumekile?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Ezinye izinhlelo zokusebenza namasevisi kungenzeka zingasebenzi ngenxa yokuxhumeka okukhawulelwe. Sebenzisa noma kunjalo?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"Ungaphindi ubuze ngale nethiwekhi"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"I-Wi-Fi ayixhunyiwe kwi-inthanethi"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"Ungashintshela kunethiwekhi yeselula noma kunini lapho i-Wi-Fi inokuxhumeka okungalungile. Izindleko zokusetshenziswa kwedatha zingasebenza."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Shintshela kuselula"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Hlala ku-Wi-Fi"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Ungaphinde uveze"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Xhuma kwi-inthanethi"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Ixhumeke ku-<xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Iyaxhuma…"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Yehlulekile ukuxhuma kunethiwekhi"</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Inethiwekhi ayikho kubanga"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Khohlwa"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Lungisa"</string>
    <string name="wifi_save" msgid="2312643132472226807">"Londoloza"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Yehlulekile ukulondoloza inethiwekhi"</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Khansela"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Khohlwa inethiwekhi?"</string>
    <string name="wifi_saved_access_points_summary" msgid="6637163320524940353">"{count,plural, =1{Inethiwekhi e-1}one{Amanethiwekhi angu-#}other{Amanethiwekhi angu-#}}"</string>
    <string name="wifi_saved_passpoint_access_points_summary" msgid="8939933724918673785">"{count,plural, =1{Okubhaliselwe oku-1}one{Okubhaliselwe okungu-#}other{Okubhaliselwe okungu-#}}"</string>
    <string name="wifi_saved_all_access_points_summary" msgid="2335870101156113858">"{count,plural, =1{Inethiwekhi e-1 nokubhaliselwe}one{Amanethiwekhi angu-# nokubhaliselwe}other{Amanethiwekhi angu-# nokubhaliselwe}}"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"I-SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"Ikheli le-MAC ledivayisi"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Ikheli le-MAC elingahleliwe"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Ikheli le-MAC elingahleliwe (ligcine ukusetshenziswa)"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Imininingwane yenethiwekhi"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Imaski ye-subnet"</string>
    <string name="wifi_type_title" msgid="2174893488722015838">"Uhlobo"</string>
    <string name="wifi_details_dns" msgid="273231528073312579">"I-DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="1913151339341722443">"Amakheli e-IPv6"</string>
    <string name="hotspot_device_details_category" msgid="3110651914598697220">"Imininingwane yedivayisi ye-hotspot"</string>
    <string name="hotspot_device_details_internet_source" msgid="1563266599673281875">"Umthombo we-inthanethi"</string>
    <string name="internet_source_wifi" msgid="6952593095166435179">"I-Wi-Fi"</string>
    <string name="internet_source_mobile_data" msgid="877403889449201789">"Idatha yeselula"</string>
    <string name="internet_source_ethernet" msgid="8338472576454100966">"I-Ethernet"</string>
    <string name="hotspot_battery_charging_summary" msgid="6690892148553288457">"Iku-<xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g> ‑ Iyashaja"</string>
    <string name="hotspot_connection_category" msgid="4320380513982923556">"Ukuxhuma ku-Hotspot"</string>
    <string name="hotspot_connection_strength" msgid="87359986943768421">"Amandla okuxhuma"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Amanethiwekhi alondoloziwe"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Okubhalisiwe"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Amanye amanethiwekhi"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Sicela uthayiphe ikheli le-IP elilungile."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Sicela uthayiphe ikheli le-IP elilungile."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Sicela uthayiphe ikheli le-IP elilungile."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Sicela uthayiphe ubude bephrifiksi yenethiwekhi phakathi kuka-0 no-32."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS 1 (ngaphandle kwalapho uma ikhishwe yi-DNS Eyimfihlo)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS 2 (ngaphandle kwalapho uma ikhishwe yi-DNS Eyimfihlo)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Indlela yokuphuma"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Ubude begama eliqalayo lenethiwekhi"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"I-Wi-Fi eqondile"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Sesha amadivayisi"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Iyasesha..."</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Qamba kabusha idivayisi"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Hlanganisa amadivayisi"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Amaqembu akhunjuliwe"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Ayikwazanga ukuxhuma."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Yehlulekile ukuqamba kabusha idivayisi."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Nqamula?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"Uma unqamula, ukuxhumana kwakho ne-<xliff:g id="PEER_NAME">%1$s</xliff:g> kuzophela."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="4490648217799144078">"Uma unqamula, ukuxhumana kwakho ne-<xliff:g id="PEER_NAME">%1$s</xliff:g> kanye namanye amadivayisi angu-<xliff:g id="PEER_COUNT">%2$s</xliff:g> kuzophela."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="8476985132989357041">"Khansela isimemo?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"Ingabe ufuna ukukhansela isimemo ukuze uxhume ne-<xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="4880242270742385699">"Khohlwa leli qembu?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"I-Wi‑Fi hotspot"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"Akukho ukwabelana kwe-inthanethi noma okuqukethwe namanye amadivayisi"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"Ayikho iphasiwedi esethiwe"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Igama le-Hotspot"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Iphasiwedi ye-Hotspot"</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Vala ama-hotspot ngokuzenzakalela"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Lapho engekho amadivayisi axhunyiwe"</string>
    <string name="wifi_hotspot_maximize_compatibility" msgid="6494125684420024058">"Nweba ukuhambelana"</string>
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary" msgid="383355687431591441">"Kusiza amanye amadivayisi athole le-hotspot. Kunciphisa ijubane lokuxhumeka ku-hotspot."</string>
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary" msgid="3579549223159056533">"Kusiza amanye amadivayisi athole le-hotspot. Ikhuphula ukusetshenziswa kwebhethri."</string>
    <string name="wifi_hotspot_speed_title" msgid="8629448084180512685">"Isivinini nokuhambisana"</string>
    <string name="wifi_hotspot_speed_summary_2g" msgid="5063438001736234858">"2.4 GHz / Ihambisana namadivayisi amaningi"</string>
    <string name="wifi_hotspot_speed_summary_5g" msgid="6221158936983135040">"5 GHz / Ihambisana namadivayisi amaningi"</string>
    <string name="wifi_hotspot_speed_summary_6g" msgid="8863992901226595544">"6 GHz / Ihambisana namadivayisi ambalwa"</string>
    <string name="wifi_hotspot_speed_summary_2g_and_5g" msgid="5931052946168943750">"2.4 kanye ne-5 GHz / Ihambisana namadivayisi amaningi"</string>
    <string name="wifi_hotspot_speed_intro" msgid="6973482196363758925">"Khetha imvamisa ye-hotspot yakho. Imvamisa ithinta isivinini sokuxhuma nokuthi yiziphi izinhlobo zamadivayisi angathola i-hotspot yakho."</string>
    <string name="wifi_hotspot_speed_category" msgid="5265655850463630286">"Imvamisa encanyelwayo"</string>
    <string name="wifi_hotspot_speed_2g" msgid="3400600834257664480">"U-2.4 GHz"</string>
    <string name="wifi_hotspot_speed_2g_summary" msgid="6930273933810520155">"Isivinini esincane. Ihambisana namadivayisi amaningi."</string>
    <string name="wifi_hotspot_speed_5g" msgid="4058116867148848395">"U-5 GHz"</string>
    <string name="wifi_hotspot_speed_5g_summary" msgid="562987935924535694">"Isivinini esisheshayo. Ihambisana namadivayisi amaningi."</string>
    <string name="wifi_hotspot_speed_2g_5g" msgid="9192756255938408285">"U-2.4 no-5 GHz"</string>
    <string name="wifi_hotspot_speed_2g_5g_summary" msgid="8104575293617700173">"Isivinini esisheshayo. Le hotspot enamabhendi amabili ihambisana namadivayisi amaningi."</string>
    <string name="wifi_hotspot_speed_6g" msgid="3787697484862730500">"U-6 GHz"</string>
    <string name="wifi_hotspot_speed_6g_summary" msgid="8675262219242174548">"Isivinini esishesha kakhulu. Ihambisana namadivayisi ambalwa."</string>
    <string name="wifi_hotspot_speed_summary_unavailable" msgid="7276080644693388756">"Ayitholakali ezweni noma esifundeni sakho"</string>
    <string name="wifi_hotspot_speed_footer" msgid="8846939503916795002">"Uma imvamisa oyincamelayo ingatholakali, i-hotspot yakho ingase isebenzise ehlukile. Amasethingi okuphepha kwe-hotspot angashintsha uma ushintsha imvamisa."</string>
    <string name="wifi_hotspot_security_summary_unavailable" msgid="117582979310345853">"Ayitholakali nge-6 GHz"</string>
    <string name="wifi_hotspot_security_footer" msgid="4608329688744949796">"Amasethingi okuphepha angashintsha uma ushintsha imvamisa ye-hotspot"</string>
    <string name="wifi_hotspot_instant_title" msgid="7052526695338853703">"I-hotspot esheshayo"</string>
    <string name="wifi_hotspot_instant_summary_on" msgid="3142749148673081288">"Ivuliwe"</string>
    <string name="wifi_hotspot_instant_summary_off" msgid="8594065628453795615">"Ivaliwe"</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Ivula i-hotspot…"</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Ivala i-hotspot…"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_title" msgid="3089432578433978073">"Ukusebenzisa ifoni njengemodemu akutholakali"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_content" msgid="5920421547607921112">"Xhumana nenkampani yakho yenethiwekhi mayelana nemininingwane."</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"I-<xliff:g id="NETWORK_SSID">%1$s</xliff:g> iyasebenza"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"Indawo ye-Android"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Londoloza le nethiwekhi?"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Iyalondoloza…"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Kulondoloziwe"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Ayikwazi ukulondoloza. Zama futhi."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Londoloza amanethiwekhi?"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Ukulondoloza amanethiwekhi angu-<xliff:g id="NUMBER">%d</xliff:g>…"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Amanethiwekhi alondoloziwe"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"Ukushaya kwe-Wi-Fi"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Nweba amakholi nge-Wi-Fi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Vula ukushaya kwe-Wi-Fi ukuze unwebe ukufakwa"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Okuncanyelwayo kokushaya"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Okuncanyelwayo kokushaya"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Okuncamelayo kokuzulazula"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Okuncamelayo kokuzulazula"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"I-Wi-Fi"</item>
    <item msgid="8622872038388687383">"Iselula"</item>
    <item msgid="3027927219952052398">"I-Wi-Fi kuphela"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"I-Wi-Fi"</item>
    <item msgid="7566603075659706590">"Iselula"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"Uma i-Wi-Fi ingatholakali, sebenzisa inethiwekhi yeselula"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"Uma inethiwekhi yeselula ingatholakali, sebenzisa i-Wi-Fi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Shaya nge-Wi-Fi. Uma i-Wi-Fi ilahleka, ikholi izophela."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"Uma kuvulwe ukushaya kwe-Wi-Fi, ifoni yakho ingahambisa amakholi ngamanethiwekhi e-Wi-Fi kunethiwekhi yenkampani yakho yenethiwekhi, ngokuya ngokuncamelayo nokuthi iyiphi isignali eqinile. Ngaphambi kokuthi uvule lesi sici, hlola nenkampani yakho yenethiwekhi ngokuphathelene nezinkokhiso kanye neminye imininingwane. <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">"Ikheli eliphuthumayo"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Isetshenziswa njengendawo yakho uma wenza ikholi ephuthumayo nge-Wi-Fi"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Funda kabanzi"</annotation>" mayelana nezici ze-Private DNS"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Kuvuliwe"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Yenza kusebenze ukushaya kwe-Wi-Fi"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Vula ukushaya kwe-Wi-Fi"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"Inqanyuliwe kusukela ku-<xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="sound_settings" msgid="7622986039384531304">"Umsindo nokudlidliza"</string>
    <string name="account_settings" msgid="255404935489127404">"Ama-akhawunti"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Ama-akhawunti wephrofayela yomsebenzi - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Ama-akhawunti wephrofayela yomuntu siqu"</string>
    <string name="accessibility_category_clone" msgid="7893383448944567885">"Yenza i-clone ama-akhawunti ephrofayela"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"I-akhawunti yomsebenzi - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"I-akhawunti yomuntu siqu - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Sesha"</string>
    <string name="display_settings" msgid="7197750639709493852">"Ukubukeka"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Phendula iskrini ngokuzenzakalela"</string>
    <string name="auto_rotate_option_off" msgid="2788096269396290731">"Valiwe"</string>
    <string name="auto_rotate_option_on" msgid="5776678230808498171">"Vuliwe"</string>
    <string name="auto_rotate_option_face_based" msgid="3438645484087953174">"Vuliwe - Kususelwe kubuso"</string>
    <string name="auto_rotate_switch_face_based" msgid="9116123744601564320">"Ukutholwa Kobuso"</string>
    <string name="auto_rotate_link_a11y" msgid="5146188567212233286">"Funda kabanzi mayelana nokuphenduka okuzenzakalelayo"</string>
    <string name="screen_resolution_title" msgid="2690518693139811486">"Ukulungiswa kwesikrini"</string>
    <string name="screen_resolution_option_high" msgid="2617496842852992853">"Ukucaca okuphezulu"</string>
    <string name="screen_resolution_option_full" msgid="2694003735219114186">"Ukucaca okugcwele"</string>
    <string name="screen_resolution_footer" msgid="6772341522952795647">"Ukucaca okugcwele kusebenzisa ibhethri yakho eyengeziwe. Ukushintsha ukucaca kwakho kungase kubangele amanye ama-app ukuthi aqale kabusha."</string>
    <string name="screen_resolution_selected_a11y" msgid="6158451180032224977">"Okukhethiwe"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Imibala"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Kwemvelo"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"I-Boost"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Ukugcwaliswa kwesikhala"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Okungaguqula"</string>
    <string name="brightness" msgid="6216871641021779698">"Izinga lokukhanya"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Ukukhanya okuguqukayo"</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"Ukukhanya kwesikrini sakho kuzolungiswa ngokuzenzakalela kumvelo yakho nakumisebenzi. Ungahambisa isilayida ngesandla ukuze usize ukukhanya okushintshayo kufunde okuncamelayo."</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"Vuliwe"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Kuvaliwe"</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Bonisa ibhalansi emhlophe"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="fold_lock_behavior_title" msgid="786228803694268449">"Qhubeka usebenzisa kuma-app agoqiwe"</string>
    <string name="disable_game_default_frame_rate_title" msgid="3712908601744143753">"Khubaza izinga lozimele elizenzakalelayo lamageyimu"</string>
    <string name="disable_game_default_frame_rate_summary" msgid="4436762704707434225">"Khubaza ukukhawulela izinga eliphezulu lozimele lamageyimu ku-<xliff:g id="FRAME_RATE">%1$d</xliff:g> Hz."</string>
    <string name="peak_refresh_rate_title" msgid="2056355754210341011">"I-Smooth display"</string>
    <string name="peak_refresh_rate_summary" msgid="3212309985294885790">"Ikhuphula ngokuzenzakalelayo izinga lokuvuselela lifike ku-<xliff:g id="ID_1">%1$d</xliff:g> Hz kokunye okuqukethwe. Ikhuphula ukusetshenziswa kwebhethri."</string>
    <string name="force_high_refresh_rate_toggle" msgid="3325789621928312050">"Phoqelela isilinganiso sokuvuselela esiphakeme"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Inani lokuvuselela eliphezulu kakhulu lokuphendula kokuthinta okuthuthukisiwe nekhwalithi yokugqwayiza. Ikhuphula ukusetshenziswa kwebhethri."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Ukunaka isikrini"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Ukufinyelela kwekhamera kuyadingeka"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5822591289468803691">"Ukufinyelela kwekhamera kuyadingeka ukunaka isikrini. Thepha ukuze uphathe izimvume Zemisebenzi Yokuqondanisa Insiza Nezidingo Zomsebenzisi"</string>
    <string name="adaptive_sleep_manage_permission_button" msgid="1404510197847664846">"Phatha izimvume"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Ivimbela isikrini sakho ekuvalweni uma usibhekile"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"Ukunaka isikrini kusebenzisa ikhamera engaphambili ukuze kwazi uma umuntu othile abheka isikrini. Kusebenza kudivayisi, futhi izithombe azilokothi zilondolozwe noma zithunyelwe ku-Google."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Vula ukunaka isikrini"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Gcina isikrini sivuliwe lapho usibhekile"</string>
    <string name="power_consumption_footer_summary" msgid="4901490700555257237">"Ukuzicisha kwesikrini okuthatha isikhathi eside kuzosebenzisa ibhethri eningi."</string>
    <string name="auto_rotate_camera_lock_title" msgid="5369003176695105872">"Ikhamera ivaliwe"</string>
    <string name="auto_rotate_camera_lock_summary" msgid="5699491516271544672">"Ikhamera kumele ivulelwe Ukutholwa Kobuso"</string>
    <string name="adaptive_sleep_camera_lock_summary" msgid="8417541183603618098">"Ikhamera kufanele ivulelwe Ukunaka Kwesikrini"</string>
    <string name="auto_rotate_summary_no_permission" msgid="1025061139746254554">"Ukufinyelela kukhamera kuyadingeka Ekutholakaleni Kobuso. Thepha ukuze uphathe izimvume Zemisebenzi Yokuqondanisa Insiza Nezidingo Zomsebenzisi"</string>
    <string name="auto_rotate_manage_permission_button" msgid="2591146085906382385">"Phatha izimvume"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Ukukhanya kwasebusuku"</string>
    <string name="night_display_text" msgid="4789324042428095383">"I-Night Light ifiphaza isikrini sakho ngoku-amber. Lokhu kungenza kubelula ukubheka esikrinini sakho noma ufunde ngokufiphele, futhi ingakusiza ukuthi ulale kalula."</string>
    <string name="night_display_auto_mode_title" msgid="5869128421470824381">"Ipulani"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Lutho"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Ivula ngesikhathi sangokwezifiso"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Ivula kusuka ekuseni kuya entambama"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Isikhathi sokuqala"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Isikhathi sokuphela"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Ukuqina"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Ngeke ize ivuleke ngokuzenzakalela"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Izovula ngokuzenzakalela ngo-<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Izovuleka ngokuzenzakalela ekushoneni kwelanga"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Ngeke ize ivaleke ngokuzenzakalela"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Izovaleka ngokuzenzakalela ngo-<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Izovaleka ngokuzenzakalela ekuphumeni kwelanga"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Ukukhanya kwasebusuku manje kuvuliwe"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Indawo yedivayisi iyadingeka ukuze kunqunywe izikhathi zakho zokushona kwelanga nezokuphuma kwelanga."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Amasethingi endawo"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Vula manje"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Vala manje"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Vula kuze kuphume ilanga"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Vala kuze kushone ilanga"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Imodi yokumnyama"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Shejula"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Lutho"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Ivula kusuka ekuseni kuya entambama"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Ivula ngesikhathi sangokwezifiso"</string>
    <string name="dark_ui_auto_mode_custom_bedtime" msgid="8465023741946439266">"Ivula isikhathi sokulala"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Isimo"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Ngeke ize ivuleke ngokuzenzakalela"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Izovuleka ngokuzenzakalela ekushoneni kwelanga"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Izovula ngokuzenzakalela ngo-<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_off_auto_mode_custom_bedtime" msgid="7759826673214624622">"Izovuleka ngokuzenzakalela ngesikhathi sokulala"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Ngeke ize ivaleke ngokuzenzakalela"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Izovaleka ngokuzenzakalela ekuphumeni kwelanga"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Izovaleka ngokuzenzakalela ngo-<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_custom_bedtime" msgid="1976993025762551246">"Izovaleka ngokuzenzakalela ngesikhathi sokulala"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"Itimu emnyama isebenzisa ingemuva elimnyama ukuze isize ukugcina ibhethri liphila isikhathi eside kwezinye izikrini. Itimu emnyama ihlelelwe ukulinga ukuvula isikrini sakho size sivale."</string>
    <string name="dark_ui_bedtime_footer_summary" msgid="5576501833145170581">"Itimu emnyama okwamanje ilandela ishejuli yemodi yesikhathi sokulala"</string>
    <string name="dark_ui_bedtime_footer_action" msgid="1493095487994054339">"Amasethingi emodi yesikhathi sokulala"</string>
    <string name="even_dimmer_display_title" msgid="8589063452814896327">"Ukufiphala Nakakhulu"</string>
    <string name="even_dimmer_display_summary" msgid="120301078873242172">"Vumela idivayisi ukuthi ifiphale kunokujwayelekile"</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Isikrini siphelelwe yisikhathi"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"Emva <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> okungasebenzi"</string>
    <string name="screen_timeout_summary_not_set" msgid="5107680774964178875">"Ayisethiwe"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Iphephadonga"</string>
    <string name="style_and_wallpaper_settings_title" msgid="2232042809407308946">"Isithombe sangemuva nesitayela"</string>
    <string name="wallpaper_dashboard_summary" msgid="2324472863981057118">"Ekhaya, ukukhiya isikrini"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Shintsha isithombe sangemuva"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Yenza isikrini sibe ngesakho"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Khetha iphephalodonga kwi"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Enza ngendlela oyifisayo ifoni yakho"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Zama izitayela ezihlukile, izithombe zangemuva, nokuningi"</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Isigcini sihenqo"</string>
    <string name="keywords_screensaver" msgid="7249337959432229172">"isigcini sesikrini"</string>
    <string name="screensaver_settings_when_to_dream_bedtime" msgid="3279310576803094771">"Akutholakali ngoba imodi yesikhathi sokulala ivuliwe"</string>
    <string name="screensaver_settings_toggle_title" msgid="6194634226897244374">"Sebenzisa isilondolozi sesikrini"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Ngenkathi ishaja noma idokhiwe"</string>
    <string name="screensaver_settings_summary_dock_and_charging" msgid="8485905100159376156">"Ngenkathi idokhiwe futhi ishaja"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Ngenkathi ishaja"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Ngenkathi idokhiwe"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Akusoze"</string>
    <string name="screensaver_settings_summary_on" msgid="4210827304351483645">"Vuliwe / <xliff:g id="SCREEN_SAVER">%1$s</xliff:g>"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Valiwe"</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Iqala nini"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Ilifti yokuvuka"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Isibonisi esi-Ambient"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Kuboniswa nini"</string>
    <string name="doze_title" msgid="1523090408230862316">"Vusa isikrini ukuthola izaziso"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Uma isikrini simnyama, sizokhanya ngokuqondene nesaziso ezintsha"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Bonisa njalo isikhathi nolwazi"</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Ukusebenza kwebhethri kukhulisiwe"</string>
    <string name="force_bold_text" msgid="4620929631102086716">"Umbhalo ogqamile"</string>
    <string name="title_font_size" msgid="570613010306330622">"Usayizi wefonti"</string>
    <string name="short_summary_font_size" msgid="8444689613442419978">"Yenza umbhalo ube mkhulu noma ube mncane"</string>
    <string name="sim_lock_settings" msgid="7331982427303002613">"Amasethingi wokukhiya i-SIM"</string>
    <string name="sim_lock_settings_category" msgid="6475255139493877786">"Khiya i-SIM"</string>
    <string name="sim_pin_toggle" msgid="6814489621760857328">"Khiya i-SIM"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Shintsha i-PIN ye-SIM"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"I-SIM PIN"</string>
    <string name="sim_enable_sim_lock" msgid="6486354334679225748">"Khiya i-SIM"</string>
    <string name="sim_disable_sim_lock" msgid="6939439812841857306">"Vula i-SIM"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"I-SIM PIN endala"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"I-SIM PIN entsha"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Thayipha kabusha IPHINIKHODI entsha"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"I-SIM PIN"</string>
    <string name="sim_invalid_pin_hint" msgid="3376397829969578877">"Thayipha Iphinikhodi enezinombolo ezingu-4 kuya kwezingu-8"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"Ama-PIN awafani"</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"I-PIN ye-SIM ishintshwe ngempumelelo"</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"Ayikwazi ukukhubaza iphinikhodi."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"Ayikwazi ukunika amandla iphinikhodi."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"KULUNGILE"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Khansela"</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"Sebenzisa i-<xliff:g id="CARRIER">%1$s</xliff:g> yedatha yeselula?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"Usebenzisa i-<xliff:g id="CARRIER2_0">%2$s</xliff:g> yedatha yeselula. Uma ushintshela ku-<xliff:g id="CARRIER1">%1$s</xliff:g>, i-<xliff:g id="CARRIER2_1">%2$s</xliff:g> ngeke isasetshenziselwa idatha yeselula"</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"Sebenzisa i-<xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="8850185380445309835">"Buyekeza i-SIM encanyelwayo?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"I-<xliff:g id="NEW_SIM">%1$s</xliff:g> iyo kuphela i-SIM ekudivayisi yakho. Ingabe ufuna ukusebenzisa le SIM kudatha yeselula, amakholi, nemilayezo ye-SMS?"</string>
    <string name="enable_auto_data_switch_dialog_title" msgid="3563043560556718994">"Thuthukisa ukusebenza kwedatha yeselula?"</string>
    <string name="enable_auto_data_switch_dialog_message" msgid="5777287241521946883">"Vumela idivaisi yakho ukuthi ishintshele ku-<xliff:g id="BACKUP_CARRIER">%1$s</xliff:g> ngokuzenzekelayo ukuze ithole idatha yeselula uma itholakala kangcono."</string>
    <string name="auto_data_switch_dialog_managed_profile_warning" msgid="6839438290079866605">\n\n"Amakholi, imiyalezo, nethrafikhi yenethiwekhi kungase kubonakale enhlanganweni yakho."</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"Ikhodi yephinikhodi ye-SIM engalungile manje kumele uxhumane nenkampini yenethiwekhi yakho ukuvula idivayisi yakho."</string>
    <string name="wrong_pin_code" msgid="8124222991071607958">"{count,plural, =1{Ikhodi engalungile Yephinikhodi ye-SIM, unomzamo o-# osele ngaphambi kokuba uxhumane nenkampani yakho yenethiwekhi ukuvula idivayisi yakho.}one{Ikhodi engalungile Yephinikhodi ye-SIM, unemizamo engu-# esele.}other{Ikhodi engalungile Yephinikhodi ye-SIM, unemizamo engu-# esele.}}"</string>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"Ikhodi engalungile yephinikhodi ye-SIM, unomzamo ongu-1 osele ngaphambi kokuba uxhumane nenkampani yakho yenethiwekhi ukuvula idivayisi yakho."</string>
    <string name="pin_failed" msgid="3726505565797352255">"Umsebenzi wephinikhodi ye-SIM wehlulekile!"</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Izibuyekezo zesistimu"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Inguqulo ye-Android"</string>
    <string name="security_patch" msgid="4071756145347865382">"Isibuyekezo sokuvikela kwe-Android"</string>
    <string name="model_info" msgid="8997566254717810904">"Imodeli"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Inguqulo yezingxenyekazi zekhompuyutha"</string>
    <string name="manufactured_year" msgid="3401517138700926475">"Unyaka eyenziwe ngayo"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"I-ID yempahla"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Inguqulo ye-Baseband"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Inguqulo ye-Kernel"</string>
    <string name="build_number" msgid="9009733242117579826">"Inombolo yesakhi"</string>
    <string name="module_version" msgid="1787518340082046658">"Isibuyekezo sesistimu se-Google Play"</string>
    <string name="battery_info" msgid="7873528123969546728">"Ulwazi lebhetri"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Akutholakali"</string>
    <string name="storage_settings" msgid="7472188817781592677">"Isitoreji"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Isitoreji nenqolobane"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Izilungiselelo zesitoreji"</string>
    <string name="status_eid" msgid="7532406028683438634">"I-EID"</string>
    <string name="eid_multi_sim" msgid="9087924808336397804">"EID (isikhala se-sim <xliff:g id="EID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim" msgid="9001570420423929507">"I-IMEI (imbobo ye-sim <xliff:g id="IMEI_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim_primary" msgid="7914653040843734282">"I-IMEI (imbobo ye-sim <xliff:g id="IMEI_SLOT_ID_PRIMARY">%1$d</xliff:g>) (eyinhloko)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Ukuze ubuke, khetha inethiwekhi elondoloziwe"</string>
    <string name="status_imei" msgid="5719752369250485007">"I-IMEI"</string>
    <string name="status_imei_sv" msgid="6908985558726440951">"I-IMEI SV"</string>
    <string name="status_min_number" msgid="4492899165438225714">"Okuncane"</string>
    <string name="status_msid_number" msgid="3871958248824595774">"MSID"</string>
    <string name="status_prl_version" msgid="9002131357502714281">"Inguqulo ye-PRL"</string>
    <string name="meid_multi_sim" msgid="1460689549266621286">"I-MEID (imbobo ye-sim <xliff:g id="MEID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="meid_multi_sim_primary" msgid="8921262417580407201">"I-MEID (imbobo ye-sim <xliff:g id="MEID_SLOT_ID_PRIMARY">%1$d</xliff:g>) (eyinhloko)"</string>
    <string name="scanning_status_text_on" msgid="3846571210578042940">"Vuliwe"</string>
    <string name="scanning_status_text_off" msgid="4002352668313705132">"Valiwe"</string>
    <string name="status_meid_number" msgid="6040380838489162650">"I-MEID"</string>
    <string name="status_icc_id" msgid="7995690631650006970">"ICCID"</string>
    <string name="status_data_network_type" msgid="3689772955330665876">"Uhlobo lwenethiwekhi yedatha yeselula"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Uhlobo lwenethiwekhi yezwi yeselula"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Ulwazi lwenkampani yenethiwekhi"</string>
    <string name="status_data_state" msgid="525196229491743487">"Isimo senethiwekhi yeselula"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"I-EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Isimo seseva"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Amandla esiginali"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Iyazulazula"</string>
    <string name="status_operator" msgid="4335640583552058491">"Inethiwekhi"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"Ikheli le-Wi-Fi MAC"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"Ikheli le-Wi‑Fi MAC ledivayisi"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"Ikheli le-Bluetooth"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Inombolo yomkhiqizo"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Isikhathi esiphezulu"</string>
    <string name="battery_manufacture_date" msgid="7139426520156833987">"Ilanga lokukhiqiza"</string>
    <string name="battery_first_use_date" msgid="3157207331722711317">"Ilanga lokuqala ukusebenzisa"</string>
    <string name="battery_cycle_count" msgid="2912949283386571900">"Isibalo somjikelezo"</string>
    <string name="battery_cycle_count_not_available" msgid="2426584515665184664">"Ayitholakali"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Iyabala..."</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Qamba kabusha"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Khweza"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Khipha"</string>
    <string name="storage_menu_format" msgid="8903698999905354146">"Fometha ikhadi le-SD ukuze uthole isitoreji esiphathekayo"</string>
    <string name="storage_menu_format_button" msgid="7623565190643699626">"Fometha ikhadi"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Ifomethi incane"</string>
    <string name="storage_menu_format_option" msgid="4886059624052908432">"Ifomethi"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Thutha idatha"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Khohlwa"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Setha"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Khulula isikhala"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Phatha isitoreji"</string>
    <string name="storage_free_up_space_title" msgid="281047807372131975">"Khulula isikhala"</string>
    <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Iya ku-app ye-Files ukuze uphathe futhi ukhulule isikhala"</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Abanye abasebenzisi"</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">"I-<xliff:g id="NAME">%1$s</xliff:g> ikhweziwe"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"Ayikwazanga ukukhweza i-<xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"I-<xliff:g id="NAME">%1$s</xliff:g> ikhishwe ngokuphephile"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"Ayikwazanga ukukhipha ngokuphephile i-<xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Qamba kabusha isitoreji"</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"Le <xliff:g id="NAME_0">^1</xliff:g> yonakele. \n\nUkuze usebenzise lokhu <xliff:g id="NAME_1">^1</xliff:g>, kufanele uyisethe kuqala."</string>
    <string name="storage_internal_format_details" msgid="2399034372813686846">"Ungafometha leli khadi le-SD ukuze ugcine izithombe, amavidiyo, umculo, nokuningi futhi ukufinyelele kwamanye amadivaysi. \n\n"<b>"Yonke idatha ekuleli khadi le-SD izosulwa."</b>" \n\n"<b>"Ngaphambi kokufometha"</b>" \n\n"<b>"Yenza isipele izithombe nenye imidiya"</b>" \nHambisa amafayela emidiya kwenye indawo yokugcina kule divayisi, noma uwadlulisele kwikhompyutha usebenzisa ikhebuli ye-USB. \n\n"<b>"Yenza isipele ama-app"</b>" \nWonke ama-app agcinwe kule <xliff:g id="NAME">^1</xliff:g> azokhishwa futhi idatha wayo izosulwa. Ukuze ugcine lama-app, wahambise kwesinye isitoreji kule divayisi."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><b>"Uma ukhipha le-<xliff:g id="NAME_0">^1</xliff:g>, izinhlelo zokusebenza ezigcinwe kuyo zizoma ukusebenza, futhi amafayela wemidiya agcinwe kuyo ngeke aze atholakale ize iphinde ifakwe."</b>\n\n"Le-<xliff:g id="NAME_1">^1</xliff:g> ifomethwe ukuze isebenze kule divayisi kuphela. Ngeke ize isebenze kwamanye."</string>
    <string name="storage_internal_forget_details" msgid="5606507270046186691">"Ukuze usebenzise izinhlelo zokusebenza, izithombe, noma idatha equkethwe yile-<xliff:g id="NAME">^1</xliff:g>, phinda uyifake. \n\nOkunye, ungakhetha ukukhohlwa yilesi sitoreji uma ngabe idivayisi ingatholakali. \n\nUma ukhetha ukukhohlwa, yonke idatha equkethwe yidivayisi izolahleka ingunaphakade. \n\nUngaphinda ufake izinhlelo zokusebenza ngemuva kwesikhathi, kodwa idatha yazo egcinwe kule divayisi izolahleka."</string>
    <string name="storage_internal_forget_confirm_title" msgid="379238668153099015">"Khohlwa i-<xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"Zonke izinhlelo zokusebenza, izithombe, nedatha elondolozwe kule <xliff:g id="NAME">^1</xliff:g> kuzolahleka ngunaphakade."</string>
    <string name="storage_detail_dialog_system" msgid="7461009051858709479">"Isistimu ibandakanya amafayela asetshenziswe ukusebenzisa inguqulo ye-Android <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="storage_wizard_guest" msgid="5813419895687733649">"Abasebenzisi bemodi yesivakashi abakwazi ukufometha amakhadi e-SD"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"Ifometha i-<xliff:g id="NAME">^1</xliff:g>…"</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Ungasusi i-<xliff:g id="NAME">^1</xliff:g> ngenkathi ifometha."</string>
    <string name="storage_wizard_ready_title" msgid="3631022511474086605">"I-<xliff:g id="NAME">^1</xliff:g> ifomethiwe"</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"Hambisa i-<xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"Ukuhambisa i-<xliff:g id="APP">^1</xliff:g> kanye nedatha yayo ku-<xliff:g id="NAME_0">^2</xliff:g> kuzothatha izikhathi ezimbalwa kuphela. Ngeke uze ukwazi ukusebenzisa uhlelo lokusebenza kuze kube ukuhanjiswa kuqedile. \n\nUngasusi i-<xliff:g id="NAME_1">^2</xliff:g> ngesikhathi sokuhambisa."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"Ukuze uhambise idatha udinga ukuvula umsebenzisi <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"Ihambisa i-<xliff:g id="APP">^1</xliff:g>…"</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"Ungasusi i-<xliff:g id="NAME">^1</xliff:g> ngesikhathi sokuhambisa. \n\nUhlelo lokusebenza lwe-<xliff:g id="APP">^2</xliff:g> kule divayisi ngeke luze lutholakale kuze kuqedwe ukuhambisa."</string>
    <string name="storage_wizard_init_v2_title" msgid="2538630338392381113">"Uzoyisebenzisa kanjani le <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"Noma"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="2786416384217054112">"Fometha ikhadi le-SD ukuze uthole isitoreji esiphathekayo"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="2002761631147966185">"Gcina izithombe, amavidiyo, umculo, nokuningi futhi ukufinyelele kwamanye amadivayisi. &lt;a href=https://support.google.com/android/answer/12153449&gt;Funda kabanzi ngokusetha ikhadi le-SD&lt;/a&gt;."</string>
    <string name="storage_wizard_init_v2_external_action" msgid="6140058734875839081">"Ifomethi"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Setha emuva kwesikhathi"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"Fomethi le <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"Le <xliff:g id="NAME_0">^1</xliff:g> idinga ukufomethiwa ukuze ilondoloze izinhlelo zokusebenza, amafayela, nemidiya. \n\nUkufometha kuzosusa okuqukethwe okukhona ku-<xliff:g id="NAME_1">^2</xliff:g>. Ukuze ugweme ukulahlekelwa okuqukethwe, kwenze isipele kwenye i-<xliff:g id="NAME_2">^3</xliff:g> noma idivayisi."</string>
    <string name="storage_wizard_format_confirm_v2_body_external" msgid="5810296966099830035">"Le <xliff:g id="NAME_0">^1</xliff:g> idinga ukufomethwa ukuze kugcinwe izithombe, amavidiyo, umculo, nokunye. \n\nUkufometha kuzosula okuqukethwe okukhona kakade ku-<xliff:g id="NAME_1">^2</xliff:g>. Ukuze ugweme ukulahlekelwa okuqukethwe, kwenze isipele kwenye i-<xliff:g id="NAME_2">^3</xliff:g> noma idivayisi."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"Ifomethi <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Hambisa okuqukethwe ku-<xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"Phakathi nokuhambisa:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"Ungaususi i-<xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Ezinye izinhlelo zokusebenza ngeke zisebenze"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Hambisa okuquethwe"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Hambisa okuqukethwe kamuva"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Ihambisa okuqukethwe…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"Ukungasheshi <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"Ungasasebenzisa le <xliff:g id="NAME_0">^1</xliff:g>, kodwa ingahle ingasheshi. \n\nIzinhlelo zokusebenza ezilondolozwe kule <xliff:g id="NAME_1">^2</xliff:g> zingahle zingasebenzi kahle, futhi ukudlulisela okuqukethwe kungathatha isikhathi eside. \n\nZama ukusebenzisa i-<xliff:g id="NAME_2">^3</xliff:g> esheshayo, noma sebenzisa le <xliff:g id="NAME_3">^4</xliff:g> ngesitoreji esiphathekayo."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Qala phansi"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Qhubeka"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="7688457485389886923">"Ungaqala ukusebenzisa i-<xliff:g id="NAME">^1</xliff:g> yakho"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="3520269956641115883">"Ungaqala ukusebenzisa i-<xliff:g id="NAME">^1</xliff:g> yakho"</string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1163588718127651062">"Ungaqala ukusebenzisa i-<xliff:g id="NAME">^1</xliff:g> yakho"</string>
    <string name="battery_status_title" msgid="4661768220545945771">"Umumo webhethri"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Izinga lebhethri"</string>
    <string name="communal_settings_title" msgid="2845678473945902115">"Okomphakathi"</string>
    <string name="communal_settings_summary" msgid="4923914136953940317">"Amasethingi omphakathi"</string>
    <string name="satellite_setting" msgid="706846910912477125">"Ukuyaleza Kwesethelayithi"</string>
    <string name="apn_settings" msgid="4295467389400441299">"APNs"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Hlela indawo yokungena"</string>
    <string name="apn_add" msgid="9069613192201630934">"Faka iphoyinti lokufinyelela"</string>
    <!-- unknown quoting pattern: original -1, translation 1 -->
    <string name="apn_not_set" msgid="8246646433109750293">"&amp;lt;Ayisethiwe&amp;gt;"</string>
    <string name="apn_not_set_for_mvno" msgid="1141490067313964640">"Ayisethiwe"</string>
    <string name="apn_name" msgid="6677695784108157953">"Igama"</string>
    <string name="apn_apn" msgid="5812828833797458602">"APN"</string>
    <string name="apn_http_proxy" msgid="1052464912365838007">"Ummeleli"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Imbobo"</string>
    <string name="apn_user" msgid="5831763936428279228">"Igama lomsebenzisi"</string>
    <string name="apn_password" msgid="7435086635953953029">"Iphasiwedi"</string>
    <string name="apn_server" msgid="6997704279138388384">"Iseva"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"Ummeleli we-MMS"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"Imbobo ye-MMS"</string>
    <string name="apn_mcc" msgid="4971414138516074809">"MCC"</string>
    <string name="apn_mnc" msgid="1926382406843447854">"MNC"</string>
    <string name="apn_auth_type" msgid="4234397513494356932">"Uhlobo lokuqinisekisa"</string>
    <string name="apn_type" msgid="1835573305077788773">"Uhlobo lwe-APN"</string>
    <string name="apn_protocol" msgid="181529867160380010">"Umthetho olandelwayo we-APN"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"Indlelaa yokuhambahamba nge-APN"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"Vula/vala i-APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"I-APN ivunyeliwe"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"I-APN ayisebenzi"</string>
    <string name="bearer" msgid="3231443241639159358">"Umthwali"</string>
    <string name="network_type" msgid="748590707422733595">"Uhlobo lwenethiwekhi"</string>
    <string name="network_type_unspecified" msgid="7756349656194518725">"Okungacacisiwe"</string>
    <string name="mvno_type" msgid="4734654257494971247">"Uhlobo lwe-MVNO"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"Inani le-MVNO"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Susa i-APN"</string>
    <string name="menu_new" msgid="6571230342655509006">"I-APN Entsha"</string>
    <string name="menu_save" msgid="6611465355127483100">"Londoloza"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Khansela"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_duplicate_apn_entry" msgid="7792928408935276618">"Phindaphinda ukufakwa kwe-apn."</string>
    <string name="error_name_empty" msgid="1258275899283079142">"Igama lenkundla akumelwe lingabi nalutho."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"I-APN akumelwe ingabi nalutho."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"Inkundla ye-MCC kumele ibe namadijithi angu-3."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"Inkundla ye-MNC kumelwe ibe amadijithi angu-2 noma angu--3"</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"Inkampani yenethiwekhi ayivumeli ukungezwa kwama-APN ohlobo lwe-%s."</string>
    <string name="error_mmsc_valid" msgid="8380951905485647380">"Inkambu ye-MMSC kufanele ibe evumelekile."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Ibuyisela izilungiselelo ezizenzakalelayo ku-APN"</string>
    <string name="menu_restore" msgid="4310539620115151551">"Setha kabusha kube okumisiwe"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Ukuhlela okumisiwe izilungiselelo ze-APN kuqedile."</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Izinketho zokusetha kabusha"</string>
    <string name="reset_mobile_network_settings_title" msgid="5616713931258506842">"Setha kabusha Amasethingi Enethiwekhi Yeselula"</string>
    <string name="reset_mobile_network_settings_desc" msgid="7292636387692165727">"Lokhu kuzosetha kabusha wonke amasethingi enethiwekhi yeselula"</string>
    <string name="reset_mobile_network_settings_confirm_title" msgid="7510965634669511241">"Setha kabusha Amasethingi Enethiwekhi Yeselula?"</string>
    <string name="reset_bluetooth_wifi_title" msgid="4113071322344697317">"Setha kabusha i-Bluetooth ne-Wi-Fi"</string>
    <string name="reset_bluetooth_wifi_desc" msgid="4030295669083059711">"Lokhu kuzosetha kabusha yonke i-Wi-Fi namasethingi e-Bluetooth. Awukwazi ukuhlehlisa lesi senzo."</string>
    <string name="reset_bluetooth_wifi_button_text" msgid="3974098137045963639">"Setha kabusha"</string>
    <string name="reset_bluetooth_wifi_complete_toast" msgid="5893439291030574365">"I-Bluetooth ne-Wi-Fi zisethwe kabusha"</string>
    <string name="reset_esim_title" msgid="4194570573425902754">"Sula ama-eSIMs"</string>
    <string name="reset_esim_desc" msgid="6125192435907740751">"Lokhu angeke kukhansele uhlelo lwesevisi yeselula yakho. Ukuze uthole ukuphindiselwa kwe-SIM, xhumana nenkampani yenethiwekhi yakho."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Setha kabusha izilungiselelo"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Setha kabusha wonek amasethingi enethiwekhi? Awukwazi ukuhlehlisa lesi senzo."</string>
    <string name="reset_network_final_desc_esim" msgid="1129251284212847939">"Setha kabusha amasethingi wenethiwekhi bese usula ama-eSIM? Awukwazi ukuhlehlisa lesi senzo."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Setha kabusha izilungiselelo"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Setha kabusha?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"Ukusetha kabusha inethiwekhi akutholakali kulo msebenzisi"</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Izilungiselelo zenethiwekhi zisethwe kabusha"</string>
    <string name="reset_esim_error_title" msgid="6516110227665862295">"Ayikwazi ukusula ama-eSIM"</string>
    <string name="reset_esim_error_msg" msgid="8459527827897797168">"Kukhona okungahambanga kahle futhi ama-eSIM awasulwanga.\n\nQala kabusha idivayisi yakho bese uphinde uyazama futhi."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Sula yonke idatha (ukusethwa kabusha njengasekuqaleni)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Sula yonke idatha (ukusethwa kabusha njengasekuqaleni)"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"Umculo"</li>\n<li>"Izithombe"</li>\n<li>"Idatha yomunye umsebenzisi"</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729">"Ama-"<li>"eSIM"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"Lokhu ngeke kukhansele uhlelo lwakho lwesevisi yefoni."</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Lonke ulwazi lwakho lomuntu siqu nezinhlelo zokusebenza ezilandiwe zizosuswa. Awukwazi ukuhlehlisa lesi senzo."</string>
    <string name="main_clear_final_desc_esim" msgid="6592404057237813989">"Lonke ulwazi lwakho lomuntu siqu, kuhlanganise nezinhlelo zokusebenza ezilandiwe nama-eSIM, kuzosuswa. Awukwazi ukuhlehlisa lesi senzo."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"Sula yonke idatha?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"Ukusetha kabusha kwasekuqaleni akutholakaleli lo msebenzisi"</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Iyasula"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Sicela ulinde…"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Izilungiselelo zekholi"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Hlela ivoyisimeyili, ukudlulisa ikholi, ikholi elindile, i-ID yomshayeli"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"Imodemu nge-USB"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"I-hotspot ephathekayo"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Imodemu nge-Bluetooth"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Ukusebenzisa njengemodemu"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"I-hotspot nokusebenzisa ifoni njengemodemu"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"I-hotspot ivuliwe, isebenzisa ifoni njengemodemu"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"I-hotspot ivuliwe"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Ukusebenzisa ifoni njengemodemu"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"Thola i-tether noma sebenzisa ama-hotspots aphathekayo ngenkathi iseva yedatha ivulekile"</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"I-Hotspot kuphela"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"I-USB kuphela"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"I-Bluetooth kuphela"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"I-Ethernet kuphela"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"I-Hotspot, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"I-Hotspot, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"I-Hotspot, i-Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth" msgid="1355680331767261967">"I-USB, Bluetooth"</string>
    <string name="tether_settings_summary_usb_and_ethernet" msgid="2195017679820919905">"I-USB, i-Ethernet"</string>
    <string name="tether_settings_summary_bluetooth_and_ethernet" msgid="1015253926959211012">"I-Bluetooth, i-Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_bluetooth" msgid="2949043525073791732">"I-Hotspot, USB, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"I-Hotspot, i-USB, i-Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"I-Hotspot, i-Bluetooth, i-Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth_and_ethernet" msgid="5880591133984166550">"I-USB, i-Bluetooth, i-Ethernet"</string>
    <string name="tether_settings_summary_all" msgid="7565193614882005775">"I-Hotspot, i-USB, i-Bluetooth, i-Ethernet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Ayabelani nge-inthanethi namanye amadivayisi"</string>
    <string name="tether_preference_summary_off" msgid="6266799346319794630">"Valiwe"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"Imodemu nge-USB"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Imodemu nge-Bluetooth"</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Ukusebenzisa ifoni njengemodemu kwe-ethernet"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Sebenzisa i-hotspot nefoni njengemodemu ukuze unikeze i-inthanethi kumanye amadivayisi ngokuxhumeka kwakho kwedatha yeselula. Izinhlelo zokusebenza nazo zingadala i-hotspot ukwabelana nokuqukethwe namadivayisi aseduze."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Sebenzisa i-hotspot nokusebenzisa ifoni njengemodemu ukuze unikeze i-inthanethi kumanye amadivayisi nge-Wi-Fi yakho noma ukuxhumeka kwedatha kweselula. Izinhlelo zokusebenza zingaphinda zidale i-hotspot ukuze zabelane ngokuqukethwe namadivayisi aseduze."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Usizo"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Inethiwekhi yeselula"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"Uhlelo lokusebenza lwe-SMS"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Shintsha uhlelo lokusebenza le-SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"Sebenzisa i-<xliff:g id="NEW_APP">%1$s</xliff:g> kunokusebenzisa i-<xliff:g id="CURRENT_APP">%2$s</xliff:g> njengohlelo lwakho lokusebenza le-SMS?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="6215622785087181275">"Sebenzisa i-<xliff:g id="NEW_APP">%s</xliff:g> njengohlelo lwakho lokusebenza le-SMS?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"Shintsha umsizi we-Wi‑Fi?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"Sebenzisa i-<xliff:g id="NEW_APP">%1$s</xliff:g> esikhundleni se-<xliff:g id="CURRENT_APP">%2$s</xliff:g> ukuze uphathe uxhumo lakho lenethiwekhi?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Sebenzisa i-<xliff:g id="NEW_APP">%s</xliff:g> ukuze uphathe uxhumo lwakho lenethiwekhi?"</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Izicelo zendawo zakamuva"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Indawo yephrofayela yokusebenza"</string>
    <string name="location_app_level_permissions" msgid="907206607664629759">"Izimvume zendawo ye-app"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Indawo ivaliwe"</string>
    <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{U-# ku-app e-{total} enokufinyelela kundawo}one{U-# kuma-app angu-{total} anokufinyelela kundawo}other{U-# kuma-app angu-{total} anokufinyelela kundawo}}"</string>
    <string name="location_category_recent_location_access" msgid="2558063524482178146">"Ukufinyelela kwakamuva"</string>
    <string name="location_recent_location_access_see_all" msgid="4203102419355323325">"Bona konke"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Buka imininingwane"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"Awekho ama-app acele imvume yendawo kamuva"</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Ayikho indawo yezinhlelo zokusebenza ezifinyelelwe kamuva nje"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Ukusebenzisa ibhethri okuphezulu"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Ukusebenzisa ibhethri okuphansi"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"Ukuskena kwe-Wi-Fi"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Vumela ama-app namasevisi ukuthi askenele amanethiwekhi e-Wi-Fi noma kunini, nanoma i-Wi-Fi ivaliwe. Lokhu kungasetshenziselwa, njengesibonelo, ukuthuthukisa izici ezisuselwa endaweni namasevisi."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Ukuskena kwe-Bluetooth"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Vumela izinhlelo zokusebenza namasevisi ukuthi askenele amadivayisi aseduze noma kunini, nanoma i-Bluetooth ivaliwe. Lokhu kungasetshenziselwa, njengesibonelo, ukuthuthukisa izici ezisuselwa endaweni namasevisi."</string>
    <string name="location_services_preference_title" msgid="604317859531782159">"Amasevisi endawo"</string>
    <string name="location_services_screen_title" msgid="5640002489976602476">"Amasevisi Endawo"</string>
    <string name="location_time_zone_detection_toggle_title" msgid="6478751613645015287">"Sebenzisa indawo"</string>
    <string name="location_time_zone_detection_status_title" msgid="8903495354385600423">"Ayikwazi ukusetha izoni yesikhathi ngokuzenzakalela"</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">"Indawo noma Amasevisi Endawo avaliwe"</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">"Indawo yedivayisi iyadingeka"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_message" msgid="5846316326139169523">"Ukuze usethe izoni yesikhathi usebenzisa indawo yakho, vula indawo, bese ubuyekeza amasethingi wezoni yesikhathi"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_ok_button" msgid="2685647335717750297">"Amasethingi endawo"</string>
    <string name="location_time_zone_provider_fix_dialog_ok_button" msgid="9026666001835079126">"Lungisa lokhu"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_cancel_button" msgid="3968729678789071154">"Khansela"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="6264253990141650280">"Izoni yesikhathi ezenzekelayo ivaliwe"</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"Ukutholwa kwendawo yezoni yesikhathi kukhutshaziwe"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"Ukutholwa kwendawo yezoni yesikhathi akusekelwe"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Izinguquko zokutholwa kwendayo yezoni yesikhathi azivunyelwe"</string>
    <string name="location_time_zone_detection_auto_is_on" msgid="8797434659844659323">"Indawo ingasetshenziselwa ukusetha izoni yesikhathi"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Buka ulwazi lomthetho, umumo wefoni, inguqulo yesofthiwe"</string>
    <string name="legal_information" msgid="7509900979811934843">"Uwazi olusemthethweni"</string>
    <string name="manual" msgid="3651593989906084868">"Ngokulawulwa"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Amalebula okuqondisa"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Imanuwali yokuphepha nokulawula"</string>
    <string name="copyright_title" msgid="83245306827757857">"I-copyright"</string>
    <string name="license_title" msgid="8745742085916617540">"Ilayisensi"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Amalayisense esibuyekezo sesistimu ye-Google Play"</string>
    <string name="terms_title" msgid="2071742973672326073">"Imigomo nemibandela"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"Ilayisense yesistimu ye-WebView"</string>
    <string name="wallpaper_attributions" msgid="4323659759250650736">"Amakhredithi wesithombe sangemuva"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Abanikezeli bezithombe zesathelayithi:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Ngokulawulwa"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Kunenkinga yokulayisha imanuwali."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Amalayisense enkampani yangaphandle"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Kunenkinga yokulayisha amalayisensi."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Iyalayisha..."</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Iyalayisha…"</string>
    <string name="lockpassword_choose_your_password_header" msgid="2407205113298094824">"Setha iphasiwedi"</string>
    <string name="lockpassword_choose_your_profile_password_header" msgid="7038997227611893312">"Setha iphasiwedi yomsebenzi"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7754265746504679473">"Setha Iphinikhodi"</string>
    <string name="lockpassword_choose_your_profile_pin_header" msgid="4581749963670819048">"Setha Iphinikhodi yomsebenzi"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="5674909390779586252">"Setha iphethini"</string>
    <string name="lockpassword_choose_your_pattern_description" msgid="6808109256008481046">"Ngokuphepha okungeziwe, setha iphethini ukuze uvule idivayisi"</string>
    <string name="lockpassword_choose_your_profile_pattern_header" msgid="3101811498330756641">"Setha iphethini yomsebenzi"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Ukuze usebenzise izigxivizo zeminwe, setha iphasiwedi"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Ukuze usebenzise izigxivizo zeminwe, setha iphethini"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Ukuze uvikelwe, setha iphinikhodi"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Ukuze usebenzise izigxivizo zeminwe, setha iphinikhodi"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Faka kabusha iphasiwedi yakho"</string>
    <string name="lockpassword_reenter_your_profile_password_header" msgid="3812040127714827685">"Faka kabusha iphasiwedi yakho yomsebenzi"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Faka iphasiwedi yakho yomsebenzi"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Qinisekisa iphethini yakho"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Faka iphethini yakho yomsebenzi"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Faka i-PIN yakho kabusha"</string>
    <string name="lockpassword_reenter_your_profile_pin_header" msgid="2890233614560435538">"Faka kabusha Iphinikhodi yakho yomsebenzi"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Faka iphinikhodi yakho yomsebenzi"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Amaphasiwedi awafani"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"Ama-PIN awafani"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Dweba iphethini yakho futhi"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Okukhethwa kukho kokuvula"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Iphasiwedi imisiwe"</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"i-PIN imisiwe"</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Iphathini imisiwe"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="622276003801157839">"Ukuze usebenzise Ukuvula ngobuso, setha iphasiwedi"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="7333603579958317102">"Ukuze usebenzise Ukuvula ngobuso, setha iphethini"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="704061826984851309">"Ukuze usebenzise Ukuvula ngobuso, setha Iphinikhodi"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="2053366309272487015">"Setha iphasiwedi ukuze usebenzise ubuso noma isigxivizo somunwe"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4038476475293734905">"Setha iphethini ukuze usebenzise ubuso noma isigxivizo somunwe"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="9086039918921009380">"Setha Iphinikhodi ukuze usebenzise ubuso noma isigxivizo somunwe"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Ukhohlwe iphasiwedi yakho?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Ukhohlwe iphethini yakho?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"Ukhohlwe iphinikhodi yakho?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7401165571170203743">"Dweba iphethini yakho ukuze uqhubeke"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="8990266101852808091">"Faka Iphinikhodi yakho ukuze uqhubeke"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="8823867445451497224">"Faka iphasiwedi yakho ukuze uqhubeke"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="7003851856761939690">"Dweba iphethini yakho yasemsebenzini ukuze uqhubeke"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Faka i-PIN yakho yomsebenzi ukuze uqhubeke"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Faka iphasiwedi yakho yomsebenzi ukuze uqhubeke"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Ngokuphepha okungeziwe, faka iphethini yedivayisi yakho"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Ngokuphepha okungeziwe, faka i-PIN yedivayisi yakho"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Ngokuphepha okungeziwe, faka iphasiwedi yedivayisi yakho"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Ngokuphepha okungeziwe, faka iphethini yakho yomsebenzi"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Ngokuphepha okungeziwe, faka i-PIN yakho yomsebenzi"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Ngokuphepha okungeziwe, faka iphasiwedi yakho yomsebenzi"</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Qinisekisa iphethini"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"Qinisekisa iphinikhodi"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Qinisekisa iphasiwedi"</string>
    <string name="lockpassword_remote_validation_header" msgid="4992647285784962073">"Qinisekisa ukuthi nguwe"</string>
    <string name="lockpassword_remote_validation_pattern_details" msgid="4655537780358707983">"Ukuze udlulisele ama-Google Account, amasethingi, nokuningi, faka iphethini yenye idivayisi yakho Iphethini yakho ibethelwe."</string>
    <string name="lockpassword_remote_validation_pin_details" msgid="2373654227583206297">"Ukuze udlulisele ama-Google Account, nokuningi, faka i-PIN yenye idivayisi yakho Iphinikhodi yakho ibethelwe."</string>
    <string name="lockpassword_remote_validation_password_details" msgid="3482328925925888340">"Ukuze udlulisele ama-Google Account, amasethingi, nokuningi, faka iphasiwedi yenye idivayisi yakho Iphasiwedi yakho ibethelwe."</string>
    <string name="lockpassword_remote_validation_set_pattern_as_screenlock" msgid="7595104317648465901">"Futhi sebenzisa iphethini ukuvula le divayisi"</string>
    <string name="lockpassword_remote_validation_set_pin_as_screenlock" msgid="509672303005547218">"Futhi sebenzisa Iphinikhodi ukuvula le divayisi"</string>
    <string name="lockpassword_remote_validation_set_password_as_screenlock" msgid="2066701840753591922">"Futhi sebenzisa iphasiwedi ukuvula le divayisi"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_header" msgid="6669435143987988314">"Qinisekisa iphethini"</string>
    <string name="lockpassword_confirm_repair_mode_pin_header" msgid="2585263648322879131">"Qinisekisa iphinikhodi"</string>
    <string name="lockpassword_confirm_repair_mode_password_header" msgid="3064676176428495228">"Qinisekisa iphasiwedi"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_details" msgid="6187536224419477465">"Sebenzisa iphethini yedivayisi yakho ukuze uqhubeke"</string>
    <string name="lockpassword_confirm_repair_mode_pin_details" msgid="203022189107305807">"Faka i-PIN yedivayisi yakho ukuze uqhubeke"</string>
    <string name="lockpassword_confirm_repair_mode_password_details" msgid="4860219600771003873">"Faka iphasiwedi yedivayisi yakho ukuze uqhubeke"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"Iphinikhodi engalungile"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Iphasiwedi engalungile"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Iphethini engalungile"</string>
    <string name="work_challenge_emergency_button_text" msgid="5529942788380505927">"Isimo esiphuthumayo"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Ukuphepha kwedivaysi"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Shintsha iphathini yokuvula"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Shintsha ukuvula i-PIN"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Dweba iphathini yokuvula"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Chofoza Imenyu ukuthola usizo."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Dedela umunwe uma usuqedile"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Xhuma okungenani amachashazi angu-<xliff:g id="NUMBER">%d</xliff:g>. Zama futhi."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Iphethini iqoshiwe"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Dweba iphethini futhi ukuze uqinisekise"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Iphethini yakho entsha yokuvula"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Qinisekisa"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Dweba kabusha"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Sula"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Qhubeka"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Vula iphathini"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Dinga iphathini"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Kumelwe udwebe iphathini ukuze uvule isikrini"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Yenza iphethini ibonakale"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_title" msgid="7172693275721931683">"Ubumfihlo Bephinikhodi ethuthukisiwe"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_summary" msgid="8639588868341114740">"Khubaza ukugqwayiza ngenkathi ufaka Iphinikhodi"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Yenza iphethini yephrofayela ibonakale"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Dlidliza uma uthepha"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Inkinobho yamandla iyakhiyeka ngokushesha"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"Ngaphandle kokuthi igcinwe ivuliwe yi-<xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="2193588309557281466">"Setha iphathini yokuvula"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Shintsha iphathini yokuvula"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Udweba kanjani phathini yokuvula"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Imizamo eminingi engalungile. Zama futhi kumasekhondi angu-<xliff:g id="NUMBER">%d</xliff:g>."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"Uhlelo lokusebenza alufakiwe efonini yakho."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Ukuvikeleka kwephrofayela yomsebenzi"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Ukukhiya isikrini kwephrofayela yomsebenzi"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Sebenzisa ukukhiya okukodwa"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Sebenzisa ukukhiya okukodwa kwephrofayela yomsebenzi nesikrini sedivayisi"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"Sebenzisa ukukhiya okukodwa?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"Idivayisi yakho izosebenzisa ukukhiya kwesikrini sephrofayela yomsebenzi. Izinqubomgomo zomsebenzi zizosebenza kokubili ukukhiya."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"Ukukhiya kwephrofayela yakho yomsebenzi akuhlangabezani nezidingo zokuvikela zenhlangano yakho. Ungasebenzisa ukukhiya okufanayo kwesikrini sedivayisi yakho nephrofayela yakho yomsebenzi, kodwa noma iziphi izinqubomgomo zokukhiya zomsebenzi zizosebenza."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Sebenzisa ukukhiya okukodwa"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Sebenzisa ukukhiya okukodwa"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Ukhiya wesikrini wedivayisi"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Phatha izinhlelo zokusebenza"</string>
    <string name="applications_settings" msgid="1941993743933425622">"Ulwazi nge-app"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"Amasethingi e-App"</string>
    <string name="install_applications" msgid="3921609656584369901">"Imithombo engaziwa"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Vumela yonke imithombo yohlelo lokusebenza"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Izinhlelo zokusebenze ezisanda kuvuleka"</string>
    <string name="see_all_apps_title" msgid="1650653853942381797">"{count,plural, =1{Bona wonke ama-app}one{Bona wonke ama-app angu-#}other{Bona wonke ama-app angu-#}}"</string>
    <string name="forgot_password_title" msgid="3967873480875239885">"Xhumana nomphathi wakho we-IT"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"Zingakusiza usethe kabusha Iphinikhodi yakho, iphethini, noma iphasiwedi"</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Izilungiselelo ezithuthukisiwe"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Nima amandla izinketho eziphezulu zezilungiselelo"</string>
    <string name="application_info_label" msgid="1015706497694165866">"Ulwazi nge-app"</string>
    <string name="storage_label" msgid="2522307545547515733">"Isitoreji"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Vula ngokuzenzekelayo"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Okuzenzekalelayo"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Ukufaneleka kwesikrini"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Izimvume"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Isilondolozi sesikhashana"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Sula inqolobane"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Isilondolozi sesikhashana"</string>
    <string name="uri_permissions_text" msgid="8406345863117405105">"{count,plural, =1{Into e-1}one{izinto ezingu-#}other{izinto ezingu-#}}"</string>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Sula ukufinyelela"</string>
    <string name="controls_label" msgid="8671492254263626383">"Izilawuli"</string>
    <string name="force_stop" msgid="2681771622136916280">"Phoqelela ukuma"</string>
    <string name="archive" msgid="9074663845068632127">"Ingobo yomlando"</string>
    <string name="restore" msgid="7622486640713967157">"Buyisela"</string>
    <string name="restoring_step_one" msgid="3465050101254272874">"Iyabuyisela"</string>
    <string name="restoring_step_two" msgid="140484846432595108">"Iyabuyisela."</string>
    <string name="restoring_step_three" msgid="3712883580876329811">"Iyabuyisela.."</string>
    <string name="restoring_step_four" msgid="8966846882470446209">"Iyabuyisela..."</string>
    <string name="total_size_label" msgid="2052185048749658866">"Konke"</string>
    <string name="application_size_label" msgid="6407051020651716729">"Usayizi wohlelo lokusebenza"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"Uhlelo lokusebenza lokugcina kwi-USB"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Idatha yomsebenzisi"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Khipha"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Kupha kubo bonke abasebenzisi"</string>
    <string name="install_text" msgid="4558333621516996473">"Faka"</string>
    <string name="disable_text" msgid="5146002260857428005">"Valiwe"</string>
    <string name="enable_text" msgid="8570798764647110430">"Vumela"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Sula isitoreji"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Khipha izibuyekezo"</string>
    <string name="app_restricted_settings_lockscreen_title" msgid="5993061278264872648">"Vumela amasethingi akhawulelwe"</string>
    <string name="auto_launch_enable_text" msgid="8912714475823807798">"Eminye imisebenzi oyikhethile ivuleka kule app ngokuzenzakalelayo."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Uvumele loluhlelo lokusebenza ukuthi lwenze amawijethi nokuthi kufinyelelwe kwidatha yawo."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"Akukho okuzenzakalelayo okusethiwe."</string>
    <string name="clear_activities" msgid="488089228657585700">"Sula okuncanyelwayo okuzenzakalelayo"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"Lolu hlelo lokusebenza kungenzeka aludalelwanga isikrini sakho; ungaphatha ukuthi ima kanjani esikrinini sakho lana."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Buza lapho isiqalisiwe"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Lungisa uhlelo lokusebenza"</string>
    <string name="unknown" msgid="8192160131923461175">"Akwaziwa"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Hlunga ngegama"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Hlunga ngosayizi"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Okwakamuva kakhulu"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Okuvamise kakhulu"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Bonisa amasevisi asebenzayo"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Bonisa izinqubo zokulondoloza kwesikhashana"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Uhlelo lokusebenza lwesimo esiphuthumayo"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Setha kabusha ama-app ayizintandokazi"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"Setha kabusha izintandokazi zohlelo lokusebenza?"</string>
    <string name="reset_app_preferences_desc" msgid="8550782670650158299">"Lokhu kuzosetha kabusha konke okuncanyelwayo kwe-:\n\n"<li>"Ama-app akhutshaziwe"</li>\n<li>"Izaziso zez-app ezikhutshaziwe"</li>\n<li>"Ama-app okuzenzakalelayo wezenzo"</li>\n<li>"Imikhawulo yedatha yangemuva yama-app"</li>\n<li>"Noma yimiphi imikhawulo yemvume"</li>\n<li>"Isethingi yokusetshenziswa kwebhethri"</li>\n\n"Ngeke uze ulahlekelwe yinoma iyiphi idatha ye-app."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Setha kabusha izinhlelo zokusebenza"</string>
    <string name="filter" msgid="9039576690686251462">"Hlunga"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Khetha okukhethwa kukho kokuhlunga"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Zonke izinhlelo zokusebenza"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Izinhlelo zokusebenza ezikhutshaziwe"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Landiwe"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Sebenzayo"</string>
    <string name="not_installed" msgid="5074606858798519449">"Akufakiwe kulo msebenzisi"</string>
    <string name="installed" msgid="2837449358488825884">"Kufakiwe"</string>
    <string name="no_applications" msgid="985069304755391640">"Azikho izinhlelo zokusebenza"</string>
    <string name="internal_storage" msgid="999496851424448809">"Isitoreji sangaphakathi"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Ilungisa kabusha usayizi..."</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Ngabe ususa yonke imininingo yohlelo lokusebenza?"</string>
    <string name="clear_data_dlg_text" msgid="3440011276559762619">"Le datha yale-app, ebandakanya amafayela namasethingi, izosuswa unaphakade kule divayisi"</string>
    <string name="dlg_ok" msgid="1421350367857960997">"KULUNGILE"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Khansela"</string>
    <string name="dlg_delete" msgid="1790919205039397659">"Sula"</string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"Uhlelo lokusebenza alutholakalanga ohlwini lwezinhlelo zokusebenza ezifakiwe."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Ayikwazanga ukusula isitoreji sohlelo lokusebenza."</string>
    <string name="computing_size" msgid="4915310659841174866">"Iyakhompyutha..."</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Ayikwazanga ukubala usayizi wephakeji."</string>
    <string name="version_text" msgid="7628938665256107608">"Inguqulo <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Hambisa"</string>
    <string name="archiving_failed" msgid="2037798988961634978">"Ukufaka kungobo yomlando kwehlulekile"</string>
    <string name="archiving_succeeded" msgid="7891249456483297845">"I-<xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> efakwe kungobo yomlando"</string>
    <string name="restoring_failed" msgid="3390531747355943533">"Ukubuyisela akuphumelelanga"</string>
    <string name="restoring_in_progress" msgid="7787443682651146115">"Kubuyiselwa i-<xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"Okunye ukuthutha sekuvele kuyaqhubeka."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"Ayikho indawo eyanele yokulondoloza."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"Ifayela ayikho"</string>
    <string name="invalid_location" msgid="8013853455355520557">"Indawo yokufaka ecacisiwe ayilungile."</string>
    <string name="system_package" msgid="7559476279008519360">"Izibuyekezo zesistimu azikwazi ukufakwa kwimidiya yangaphandle"</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Uhlelo lokusebenza lomlawuli wedivayisi alikwazi ukufakwa kumidiya yangaphandle"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Phoqelela ukumisa"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Uma uphoqa ukumisa uhlelo lokusebenza, kungenzeka ukuthi lungasebenzi."</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Khubaza uhlelo lokusebenza"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"Uma ukhubaza lolu hlelo lokusebenza, i-Android nezinye izinhlelo zokusebenza kungenzeka zingasasebenzi njengoba zihlosiwe. Khumbula, awukwazi ukususa lolu hlelo lokusebenza njengoba luze lufakwe ngaphambilini kudivayisi yakho. Ngokukhubaza, uvala lolu hlelo lokusebenza futhi uyalifihla kudivayisi yakho."</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Isitolo"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Imininingwane yohlelo lokusebenza"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"Uhlelo lokusebenza lufakiwe kusuka ku-<xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Ulwazi oluningi ku-<xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"Sebenzayo"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Ayikaze yasetshenziswa)"</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Ukusetshensiswa kwesitoreji"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Iqalisa phansi"</string>
    <string name="cached" msgid="5379485147573438201">"Inqubo yasemuva yokulondoloza okwesikhashana"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Akukho okusebenzayo."</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Kuqalwe uhlelo lokusebenza."</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> vulekile"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"<xliff:g id="MEMORY">%1$s</xliff:g> sebenzile"</string>
    <string name="memory" msgid="5253757199926592074">"i-RAM"</string>
    <!-- no translation found for service_process_name (7827318358399776412) -->
    <skip />
    <string name="running_process_item_user_label" msgid="1444898861984132133">"Umsebenzisi: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Umsebenzisi osusiwe"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> inqubo <xliff:g id="NUMSERVICES">%2$d</xliff:g> amasevisi"</string>
    <string name="running_processes_item_description_s_p" msgid="1209371773353932361">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> izinqubo <xliff:g id="NUMSERVICES">%2$d</xliff:g> namasevisi"</string>
    <string name="running_processes_item_description_p_s" msgid="8957061449107822282">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> izinqubo kanye <xliff:g id="NUMSERVICES">%2$d</xliff:g> nensizakalo"</string>
    <string name="running_processes_item_description_p_p" msgid="3292999232897469679">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> izinqubo <xliff:g id="NUMSERVICES">%2$d</xliff:g> namasevisi"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Imemori yedivayisi"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"Ukusethenziswa kwe-RAM yohlelo lokusebenza"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"Isistimu"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Izinhlelo zokusebenza"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Khululekile"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Okusetshenzisiwe"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"Kufakwe kwinqolobane"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> we-RAM"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Uhlelo lokusebenza olusebenzayo"</string>
    <string name="no_services" msgid="3898812785511572899">"Akusebenzi"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Amasevisi"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Izinqubo"</string>
    <string name="service_stop" msgid="5712522600201308795">"Misa"</string>
    <string name="service_manage" msgid="3896322986828332075">"Izilungiselelo"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"Le nsizakalo iqaliswe uhlelo lwayo lokusebenza. Ukuyimisa kungase kubangele ukuba uhlelo lwehluleke."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"Lolu hlelo lokusebenza alukwazi ukumiswa ngokuphepha. Uma ulumisa kungenzeka ukuthi ulahlekelwe ngeminye yemisebenzi oyenzayo manje."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"Lolu uhlelo lohlelo lokusebenza oludala olusasebenza ukulungiselela mhla ludingeka futhi. Ngokujwayelekile asibikhona isidingo sokulumisa."</string>
    <string name="service_manage_description" msgid="6615788996428486121">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: okwamanje kuyasebenza. Thepha izilungiselelo ukuze ulawule."</string>
    <string name="main_running_process_description" msgid="6685973937935027773">"Inqubo eyinhloko esetshenziswayo."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"Isevisi <xliff:g id="COMP_NAME">%1$s</xliff:g> iyasebenza"</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"Umhlinzeki <xliff:g id="COMP_NAME">%1$s</xliff:g> uyasebenza."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Misa isevisi yesistimu?"</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Izilimi, okokufaka nokuthinta"</string>
    <string name="language_settings" msgid="8700174277543875046">"Izilimi nokokufaka"</string>
    <string name="languages_settings" msgid="5784775502251770671">"Izilimi"</string>
    <string name="keyboard_settings" msgid="184185708597386454">"Ikhibhodi"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Awunayo imvume yokushintsha ulwimi lwedivayisi."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Izilimi nokokufaka"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Amathuluzi"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Ikhibhodi &amp; izindlela zokufaka"</string>
    <string name="system_language" msgid="1146762166579643257">"Izilimi Zesistimu"</string>
    <string name="phone_language" msgid="5986939176239963826">"Izilimi"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Ukubuyisela okuzenzakalelayo"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Lungisa amagama angathayiphwanga kahle"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Ukwenza ofeleba okuzenzakalelayo"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Khulisa igama lokuqala lomusho"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Ngamfula ngokuzenzakalelayo"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Izilungiselelo zokwakheka kwangampela kwekhibhodi"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Chofoza ukhiye Wesikhala kabili  ukufaka \".\""</string>
    <string name="show_password" msgid="7101900779571040117">"Bonisa amaphasiwedi"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Bonisa izinhlamvu kancane njengoba uthayipha"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"Lokhu okuhlola ukupela kungenzeka ukuthi kuthole yonke imibhalo oyibhalayo, okuhlanganisa imininingo yakho efana naphasiwedi kanye nezinombolo ze-credit card. Kuqhamuka kuhlelo lokusebenza <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Ngabe kungasetshenziswa okuhlola ukupela?"</string>
    <string name="spellchecker_quick_settings" msgid="6449414356743946577">"Izilungiselelo"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Ulimi"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Amakhibhodi"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Ikhibhodi ekuskrini"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"I-Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Ikhibhodi ekusikrini etholakalayo"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Phatha amakhibhodi akuskrini"</string>
    <string name="keyboard_options_category" msgid="8040137073401152608">"Ongakukhetha"</string>
    <string name="keyboard_a11y_category" msgid="8230758278046841469">"Ukufinyeleleka"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Ikhibhodi ephathekayo"</string>
    <string name="show_ime" msgid="4334255501724746849">"Sebenzisa ikhibhodi ekuskrini"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Yigcine kusikrini ngenkathi kusebenza ikhibhodi ephathekayo"</string>
    <string name="bounce_keys" msgid="7419450970351743904">"Okhiye bokubuyisela emuva"</string>
    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
    <skip />
    <string name="slow_keys" msgid="2891452895499690837">"Okhiye abahamba kancane"</string>
    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
    <skip />
    <string name="sticky_keys" msgid="7317317044898161747">"Okhiye abanamathelayo"</string>
    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
    <skip />
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Izinqamuleli zekhibhodi"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Bonisa uhlu lwezinqamuleli"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Amakhibhodi ephrofayela yomsebenzi namathuluzi"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Ikhibhodi ekuskrini yomsebenzi"</string>
    <string name="keyboard_default_layout" msgid="5377811770620422301">"Okuzenzakalelayo"</string>
    <string name="trackpad_settings" msgid="2071131324087677005">"Iphedi yokuthinta"</string>
    <string name="trackpad_mouse_settings" msgid="136226693583218429">"Iphedi yokuthinta ne-mouse"</string>
    <string name="trackpad_settings_summary" msgid="3369855644136760402">"Isivinini sesikhombi, ukunyakaza komzimba"</string>
    <string name="trackpad_tap_to_click" msgid="1938230946542070746">"Thepha ukuze uchofoze"</string>
    <string name="trackpad_touchpad_gesture_title" msgid="7568052847609914436">"Ukunyakaziswa kwephedi lokuthinta"</string>
    <string name="trackpad_touchpad_gesture_summary" msgid="6256074591395359124">"Enza ngendlela oyifisayo ukuthinta ngakunye kwephedi lokuthinta"</string>
    <string name="trackpad_reverse_scrolling_title" msgid="422877284529360866">"Ukuskrola okubuyiselwe emuva"</string>
    <string name="trackpad_reverse_scrolling_summary" msgid="6048648562887499036">"Okuqukethwe kuya phezulu uma uskrolela phansi"</string>
    <string name="trackpad_bottom_right_tap_title" msgid="6275428879042702880">"Thepha phansi kwesokudla"</string>
    <string name="trackpad_bottom_right_tap_summary" msgid="8734094086900680674">"Thepha ekhoneni elingezansi kwesokudla lephedi yokuthinta ukuze uthole okungakhethwa kukho okwengeziwe"</string>
    <string name="trackpad_pointer_speed" msgid="7786579408631352625">"Ijubane lesikhombi"</string>
    <string name="trackpad_touch_gesture" msgid="8641725062131922497">"Funda ukunyakaza kwephedi lokuthinta"</string>
    <string name="keywords_touchpad" msgid="8159846254066666032">"i-trackpad, i-track pad, imawuzi, i-cursor, skrola, swayipha, chofoza kwesokudla, chofoza, isikhombi"</string>
    <string name="keywords_trackpad_bottom_right_tap" msgid="1285062446073929305">"chofoza ngakwesokudla, thepha"</string>
    <string name="gesture_title_go_home" msgid="3682238648647225933">"Iya ekhasini lokuqala"</string>
    <string name="gesture_summary_go_home" msgid="6409031586904205741">"Swayiphela phezulu ngeminwe emithathu noma kuphi kuphedi yakho yokuthinta"</string>
    <string name="gesture_title_go_back" msgid="6619462058488419802">"Iya emuva"</string>
    <string name="gesture_summary_go_back" msgid="4981604277892236888">"Swayipha kusuka kwesobunxele noma kwesokudla ngeminwe emithathu"</string>
    <string name="gesture_title_recent_apps" msgid="6082688963233208761">"Buka ama-app akamuva"</string>
    <string name="gesture_summary_recent_apps" msgid="6643179135202417509">"Swayiphela phezulu ngeminwe emithathu, ubambe, bese uyakhulula"</string>
    <string name="gesture_title_notifications" msgid="791717222472350194">"Buka izaziso Namasethingi Asheshayo"</string>
    <string name="gesture_summary_notifications" msgid="8419514601638387255">"Swayiphela phansi ngeminwe emithathu esikrinini sakho sasekhaya"</string>
    <string name="gesture_title_switch_apps" msgid="5840994412037872157">"Shintsha ama-app"</string>
    <string name="gesture_summary_switch_apps" msgid="6842648062151413042">"Swayiphela kwesokunxele noma kwesokudla ngeminwe emine"</string>
    <string name="gesture_button_skip" msgid="5174842083451193213">"Yeqa"</string>
    <string name="gesture_button_next" msgid="695288092704187356">"Okulandelayo"</string>
    <string name="gesture_button_restart" msgid="1895850891992530133">"Qala kabusha"</string>
    <string name="gesture_button_done" msgid="6387900351203032188">"Kwenziwe"</string>
    <string name="trackpad_go_back_title" msgid="5312164160947491440">"Iya emuva"</string>
    <string name="trackpad_go_back_summary" msgid="4201901101085902768">"Swayiphela kwesokunxele noma kwesokudla ngeminwe emithathu"</string>
    <string name="trackpad_go_home_title" msgid="2146525662148291552">"Iya ekhasini lokuqala"</string>
    <string name="trackpad_go_home_summary" msgid="2222744701528360887">"Swayiphela phezulu ngeminwe emithathu"</string>
    <string name="trackpad_recent_apps_title" msgid="8195970908411585445">"Ama-app wakamuva+"</string>
    <string name="trackpad_recent_apps_summary" msgid="2685092851677573794">"Swayiphela phezulu ngeminwe emithathu, bese uyabamba"</string>
    <string name="trackpad_notifications_title" msgid="3521663305043747880">"Izaziso"</string>
    <string name="trackpad_notifications_summary" msgid="7663647367648690040">"Swayiphela phansi ngeminwe emithathu"</string>
    <string name="trackpad_switch_apps_title" msgid="7342032935377284039">"Shintsha ama-app"</string>
    <string name="trackpad_switch_apps_summary" msgid="9193942041912927440">"Swayiphela kwesokunxele noma kwesokudla ngeminwe emine"</string>
    <string name="modifier_keys_settings" msgid="2537108435032034683">"Okhiye bokushintsha"</string>
    <string name="modifier_keys_settings_summary" msgid="6933143361657444436">"Shintsha ukuziphatha kokhiye"</string>
    <string name="modifier_keys_reset_title" msgid="948294258402761066">"Setha kabusha konke"</string>
    <string name="modifier_keys_default_summary" msgid="8701640508670973258">"Okuzenzakalelayo"</string>
    <string name="modifier_keys_reset_message" msgid="5236994817619936058">"Uqinisekile ukuthi ungathanda ukusetha kabusha bonke okhiye bokushintsha babe yizimiso zabo?"</string>
    <string name="modifier_keys_done" msgid="8196199314913909700">"Kwenziwe"</string>
    <string name="modifier_keys_cancel" msgid="7136520252570826772">"Khansela"</string>
    <string name="modifier_keys_reset" msgid="551170906710422041">"Setha kabusha"</string>
    <string name="modifier_keys_picker_title" msgid="244545904150587851">"Khetha ukhiye wokushintsha"</string>
    <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Khetha ukhiye omusha we-<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"Okuzenzakalelayo"</string>
    <string name="speech_category_title" msgid="5995161659186229742">"Inkulumo"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Ijubane lesikhombi"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Isilawuli somdlalo"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Qondisa kabusha ukudlidliza"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Thumela ukudlidliza kwesilawuli segeyimu uma kuxhunyiwe"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Khetha isendlalelo sekhibhodi"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Setha izendlalelo zamakhibhodi"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Ukuze ushintshe, cindezela u-Control-Spacebar"</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Okuzenzakalelayo"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Izendlalelo zekhibhodi"</string>
    <string name="keyboard_layout_picker_category_title" msgid="2369473692906329772">"Izakhiwo zekhibhodi ebonakalayo"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Isichazamazwi somuntu siqu"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Isichazamazwi somuntu siqu sokusebenza"</string>
    <string name="user_dict_settings_summary" msgid="4939694372338975081">"Faka amagama azosetshenziswa kuma-app afana nesihloli sokupela"</string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Engeza"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Faka kwisichazamazwi"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Umshwana"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Izinketho eziningi"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Izinketho ezincane"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"KULUNGILE"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Igama:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Isinqamulelo:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Ulimi:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Thayipha igama"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Ukunqamulela okukhethekayo"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Hlela igama"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Hlela"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Susa"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"Awunawo amagama kwisichazamazwi somsebenzisi. Ukuze ungeze igama, thepha inkinobho (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"Kwezilimi"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Izilimi eziningi…"</string>
    <string name="testing" msgid="6294172343766732037">"Iyahlola"</string>
    <string name="keyboard_settings_summary" msgid="9188442758316476986">"Ikhibhodi kuskrini, amathuluzi"</string>
    <string name="keyboard_settings_with_physical_keyboard_summary" msgid="2240779804018260938">"Ikhibhodi kuskrini, ikhibhodi engokoqobo, amathuluzi"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Ukwakheka kwekhibhodi"</string>
    <string name="enabled_locales_keyboard_layout" msgid="3939886151098958639">"Isakhiwo"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Khetha igajethi"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Khetha iwijethi"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Yenza iwijethi bese uvumela ukufinyeleleka?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5825298768068148804">"Emva kokudala iwijethi, i-application ingafinyelela kukho konke okuboniswayo.\n\nI-application: <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g>\nIwijethi: <xliff:g id="WIDGET_LABEL">%2$s</xliff:g>\n"</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7268758525344468364">"Ivumele njalo u-<xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> ukuthi enze amawijethi bese efinyelela kwidatha yawo"</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Izibalo zokusetshenziswa"</string>
    <string name="usage_stats_sort_by_usage_time" msgid="2927310334119998301">"Hlunga ngesikhathi sokusebenzisa"</string>
    <string name="usage_stats_sort_by_last_time_used" msgid="7039213339779884017">"Hlunga ngesikhathi sokugcina esetshenziswe ngaso"</string>
    <string name="usage_stats_sort_by_app_name" msgid="4463833145514850478">"Hlunga ngegama le-app"</string>
    <string name="last_time_used_label" msgid="7589377271406011659">"Igcinwe ukusetshenziswa"</string>
    <string name="last_time_used_never" msgid="2936073559267990034">"ngeke"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Isikhathi sokusetshenziswa"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Ukufinyeleleka"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Izilungiselelo zokufinyelela"</string>
    <string name="accessibility_settings_summary" msgid="2366627644570558503">"Bonisa, ukusebenzisana, umsindo"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Izilungiselelo zokubonakala"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"Ungenza ngendlela oyifisayo le divayisi ukuze ihlangabezane nezidingo zakho. Lezi zici ezingafinyeleleka zingashintshwa ngemuva kwesikhathi kuzilungiselelo."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Shintsha usayizi wefonti"</string>
    <string name="screen_reader_category_title" msgid="5825700839731107803">"Isifundi sesikrini"</string>
    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
    <skip />
    <string name="captions_category_title" msgid="574490148949400274">"Amagama-ncazo"</string>
    <string name="audio_category_title" msgid="5283853679967605826">"Umsindo"</string>
    <string name="general_category_title" msgid="6298579528716834157">"Okuvamile"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Bonisa"</string>
    <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Umbala nokunyakaza"</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">"Yenza isikrini sibe mnyama"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Izilawuli zokubandakanya"</string>
    <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Izilawuli zesikhathi"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Izilawuli zesistimu"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Izinhlelo zokusebenza ezila"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Okokulinga"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Faka amafulegi"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_title" msgid="401330708633716596">"Ukuhlunga ilogu yokucupha i-Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_summary" msgid="1319792184194176235">"Setha izihlungi"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_footer" msgid="4158945851818483666">"Khubaza futhi nika amandla i-Bluetooth yezinguquko ezizosebenza"</string>
    <string name="bt_hci_snoop_log_filter_pbap_title" msgid="1735427364451634823">"I-PBAP yokuhlunga ilogu yokucupha i-Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filter_map_title" msgid="180092480793945544">"I-MAP yokuhlunga ilogu yokucupha i-Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filter_summary" msgid="7217091930762522599">"Setha imodi yokuhlunga. (Khubaza futhi unike amandla i-Bluetooth yezinguquko ezizosebenza)"</string>
    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary" msgid="8824952559433361848">"Setha imodi yelogu yokucupha i-Bluetooth HCI Kokuhlungiwe okunikwe amandla ukushintsha lokhu okukhethwa kukho"</string>
    <string name="talkback_title" msgid="8756080454514251327">"I-Talkback"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Isifundi sesikrini kakhulukazi esabantu abangaboni nabanokubona okuncane"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Thepha izinto esikrinini sakho ukuze uzizwe zifundelwa phezulu"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Okuncanyelwayo kwamagama-ngcazo"</string>
    <string name="accessibility_captioning_about_title" msgid="3542171637334191563">"Mayelana nezincomo zegama-ncazo"</string>
    <string name="accessibility_captioning_footer_learn_more_content_description" msgid="5730040700677017706">"Funda kabanzi ngokuncanyelwayo kwegama-ncazo"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Ukukhuliswa"</string>
    <string name="accessibility_screen_magnification_shortcut_title" msgid="2387963646377987780">"Isinqamuleli sokukhuliswa"</string>
    <string name="accessibility_screen_magnification_follow_typing_title" msgid="6379517513916651560">"Khulisa ukuthayipha"</string>
    <string name="accessibility_screen_magnification_follow_typing_summary" msgid="2882250257391761678">"Isikhulisi silandela umbhalo njengoba uthayipha"</string>
    <string name="accessibility_screen_magnification_always_on_title" msgid="3814297443759580936">"Qhubeka ngenkathi ushintsha ama-app"</string>
    <string name="accessibility_screen_magnification_always_on_summary" msgid="306908451430863049">"Isikhulisi sihlala sivuliwe futhi siyahlehlisa lapho ushintsha ama-app"</string>
    <string name="accessibility_screen_magnification_joystick_title" msgid="1803769708582404964">"I-joystick"</string>
    <string name="accessibility_screen_magnification_joystick_summary" msgid="4640300148573982720">"Yenza kusebenze futhi uhambise isikhulisi ngenduku yokudlala esesikrinini. Thepha futhi ubambe, bese uhudula induku yokudlala ukuze ulawule isikhulisi. Thepha futhi uhudule ukuze uhambise induku yokudlala ngokwayo."</string>
    <string name="accessibility_screen_magnification_about_title" msgid="8857919020223505415">"Mayelana nokukhuliswa"</string>
    <string name="accessibility_screen_magnification_footer_learn_more_content_description" msgid="924848332575978463">"Funda kabanzi mayelana nokukhuliswa"</string>
    <string name="accessibility_magnification_mode_title" msgid="8446475127807168063">"Uhlobo lokukhulisa"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="8498648925928109462">"Khulisa isikrini sakho esigcwele, indawo ethile, noma shintsha phakathi kwazo zombili izinketho."</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Iskrini esigcwele"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="9191632962955877019">"Isikrini esiyingxenye"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="8107511976748799455">"Shintsha phakathi kwesikrini esigcwele nesiyingxenye"</string>
    <string name="accessibility_magnification_mode_dialog_title" msgid="9151027667059878578">"Khetha indlela yokukhulisa"</string>
    <string name="accessibility_magnification_mode_dialog_option_full_screen" msgid="4892487869954032029">"Khulisa isikrini esigcwele"</string>
    <string name="accessibility_magnification_mode_dialog_option_window" msgid="4492443201099153362">"Khulisa ingxenye eyesikrini"</string>
    <string name="accessibility_magnification_mode_dialog_option_switch" msgid="561043521011229424">"Shintsha phakathi kwesikrini esigcwele nesiyingxenye"</string>
    <string name="accessibility_magnification_area_settings_mode_switch_summary" msgid="2885238806099080966">"Thepha inkinobho yokushintsha ukuze uhambe phakathi kwazo zombili izinketho"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Ushintshela enkinobhweni yokufinyelela?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="7718653917415163833">"Ukusebenzisa ukuthepha kathathu ukuze ukhulise ingxenye yesikrini sakho kubangela ukuthayipha kanye nezinye iziphazamiso.\n\nInkinobho yokufinyeleleka intanta kusikrini ngaphezu kwama-app wakho. Thepha ukuze ukhulise."</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Shintshela kunkinobho yokufinyelela"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="7115794462123071594">"Sebenzisa ukuthepha kathathu"</string>
    <string name="accessibility_magnification_triple_tap_warning_title" msgid="8484669851397296597">"Lokhu kungase kwehlise isivinini sekhibhodi yakho"</string>
    <string name="accessibility_magnification_triple_tap_warning_message" msgid="2008671502848936410">"Lapho usebenzisa ukuthepha kathathu ukukhulisa ingxenye yesikrini sakho, ungase uqaphele izinkinga kukhibhodi.\n\nUkugwema lokhu, ungashintsha isinqamuleli sokukhuliswa ngokuthepha kathathu kwenye inketho.\n"<annotation id="link">"Shintsha isethingi"</annotation></string>
    <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Qhubeka noma kunjalo"</string>
    <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Khansela"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Izilungiselelo zokukhuliswa"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Khulisa ngesinqamuleli"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Khulisa ngenkinobho futhi uthephe kathathu"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"Mayelana ne-<xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_text_reading_options_title" msgid="3224648909213325563">"Bonisa usayizi nombhalo"</string>
    <string name="accessibility_text_reading_options_suggestion_title" msgid="2492155642665312733">"Shintsha indlela umbhalo obonakala ngayo"</string>
    <string name="accessibility_text_reading_preview_mail_subject" msgid="4597374768612733616">"Isihloko: Amadizayini wamabhamuza womoya oshisayo"</string>
    <string name="accessibility_text_reading_preview_mail_from" msgid="1797499780365288020">"Kusuka ku-: Bill"</string>
    <string name="accessibility_text_reading_preview_mail_content" msgid="8078152365771951802">"Sawubona!\n\nBengifuna ukuhlola ukuthi amadizayini eza kanjani. Ingabe azobe elungile ngaphambi kokuthi siqale ukwakha amabhamuza amasha?"</string>
    <string name="accessibility_text_reading_reset_button_title" msgid="5960753279788187669">"Setha kabusha amasethingi"</string>
    <string name="accessibility_text_reading_reset_message" msgid="824644303661026712">"Usayizi wesibonisi namasethingi ombhalo asethwe kabusha"</string>
    <string name="accessibility_text_reading_confirm_dialog_title" msgid="2865331351355690389">"Setha kabusha usayizi wokubonisa nombhalo?"</string>
    <string name="accessibility_text_reading_confirm_dialog_reset_button" msgid="8215800137850243736">"Setha kabusha"</string>
    <string name="accessibility_text_reading_conversation_message_1" msgid="7883952203831957831">"Unezinhlelo zempelasonto?"</string>
    <string name="accessibility_text_reading_conversation_message_2" msgid="8112160435318635856">"Ngiya olwandle. Ufuna ukuhamba nami?"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Izinketho"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Sondeza isithombe kusikrini"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Thepha izikhathi ezingu-3 ukuze usondeze"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Thepha inkinobho ukuze usondeze"</string>
    <string name="accessibility_screen_magnification_intro_text" msgid="3856180549393526339">"Sondeza isithombe ngokushesha ukuze wenze okuqukethwe kube kukhudlwana"</string>
    <string name="accessibility_screen_magnification_summary" msgid="8267672508057326959">"&lt;b&gt;Ukuze usondeze isithombe:&lt;br/&gt;&lt;br/&gt; {0,number,integer}. Sebenzisa isinqamuleli ukuqalisa ukukhuliswa&lt;/b&gt;&lt;br/&gt; {1,number,integer}. Thepha isikrini&lt;/b&gt;&lt;br/&gt; {2,number,integer}. Hudula iminwe emi-2 ukuze uhambe esikrinini&lt;/b&gt;&lt;br/&gt; {3,number,integer}. Ncinza ngeminwe emi-2 ukuze ulungise ukusondeza&lt;/b&gt;&lt;br/&gt; {4,number,integer}. Sebenzisa isinqamuleli ukuze umise ukukhuliswa&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Ukuze usondeze isithombe okwesikhashana:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Qiniseka ukuthi uhlobo lwakho lokukhulisa lusethwe esikrinini esigcwele&lt;/b&gt;&lt;br/&gt; {1,number,integer}. Sebenzisa isinqamuleli ukuqalisa ukukhuliswa&lt;/b&gt;&lt;br/&gt; {2,number,integer}. Thinta futhi ubambe noma kuphi esikrinini&lt;/b&gt;&lt;br/&gt; {3,number,integer}. Hudula umunwe ukuze uhambahambe esikrinini&lt;/b&gt;&lt;br/&gt; {4,number,integer}. Phakamisa umunwe ukuze umise ukukhuliswa"</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Uma ukukhulisa kuvuliwe, ungasondeza isikrini sakho.\n\n"<b>"Ukuze usondeze"</b>", qala ukukhulisa, thepha noma yikuphi kusikrini.\n"<ul><li>"Hudula iminwe engu-2 noma ngaphezulu ukuze uskrole"</li>\n<li>"Ncinza iminwe engu-2 noma ngaphezulu ukuze ulungisa ukusondela"</li></ul>\n\n<b>"Ukuze usondeze okwesikhashana"</b>", qalisaukukhulisa, bese uthinte futhi ubambe noma yokuhi esikrinini.\n"<ul><li>"Hudula ukuze uhambahambe esikrinini"</li>\n<li>"Phakamisa umunwe ukuze uhlehlise isithombe"</li></ul>\n\n"Awukwazi ukusondeza kwikhibhodi noma kwibha yokuzula."</string>
    <string name="accessibility_tutorial_pager" msgid="8461939455728454061">"Ikhasi elingu-<xliff:g id="CURRENT_PAGE">%1$d</xliff:g> kwangu-<xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Sebenzisa inkinobho yokufinyelela ukuze uvule"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Bamba okhiye bevolumu ukuze uvule"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Thepha kathathu isikrini ukuvula"</string>
    <string name="accessibility_tutorial_dialog_title_two_finger_double" msgid="3912970760484557646">"Thepha kabili isikrini ngeminwe emibili ukuze uvule"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Sebenzisa ukuthinta ukuze uvule"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="6800684770875867559">"Sebenzisa ukufinyeleleka kokuthinta"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Ukuze usebenzise lesi sici, thepha inkinobho yokufinyeleleka <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> ngezansi kwesikrini.\n\nUkushintsha phakathi kwezici, thinta futhi ubambe inkinobho yokufinyeleleka."</string>
    <string name="accessibility_tutorial_dialog_message_floating_button" msgid="2551777208185138391">"Ukuze usebenzise lesi sici, thepha inkinobho yokufinyeleleka kusikrini sakho."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Ukuze usebenzise lesi sici, cindezela futhi ubambe bobabili okhiye bevolumu."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Ukuqala nokumisa ukukhuliswa, thepha kathathu noma kuphi kusikrini."</string>
    <string name="accessibility_tutorial_dialog_message_two_finger_triple" msgid="860548190334486449">"Ukuze uqale futhi umise ukukhuliswa, thepha kabili noma yikuphi esikrinini sakho ngeminwe emibili."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Ukuze usebenzise lesi sici, swayiphela phezulu kusuka ezansi esikrinini ngeminwe emi-2.\n\nUkuze ushintshe phakathi kwezici, swayiphela phezulu ngeminwe emi-2 bese ubambe."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Ukuze usebenzise lesi sici, swayiphela phezulu kusuka ezansi esikrinini ngeminwe emi-3.\n\nUkuze ushintshe phakathi kwezici, swayiphela phezulu ngeminwe emi-3 bese ubambe."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Ukuze usebenzise isici sokufinyelela, swayiphela phezulu kusuka ezansi esikrinini ngeminwe emi-2.\n\nUkuze ushintshe phakathi kwezici, swayiphela phezulu ngeminwe emi-2 bese ubambe."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Ukuze usebenzise isici sokufinyelela, swayiphela phezulu kusuka ezansi esikrinini ngeminwe emi-3.\n\nUkuze ushintshe phakathi kwezici, swayiphela phezulu ngeminwe emi-3 bese ubambe."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"Ngiyezwa"</string>
    <string name="accessibility_tutorial_dialog_link_button" msgid="6797349445794031781">"Amasethingi wenkinobho"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"<xliff:g id="SERVICE">%1$s</xliff:g> isinqamuleli"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Inkinobho yokufinyeleleka"</string>
    <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Ukutholakala kokuthinta"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Swayiphela phezulu ngeminwe engu-2"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Swayiphela phezulu ngeminwe engu-3"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Thepha inkinobho yokufinyeleleka"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture" msgid="3981188764050497346">"Sebenzisa ukufinyeleleka kokuthinta"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Thepha inkinobho yokufinyeleleka <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> ezansi esikrinini sakho.\n\nUkuze ushintshe phakathi kwezici, thinta futhi ubambe inkinobho yokufinyeleleka."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Swayiphela phezulu kusuka ezansi esikrinini ngeminwe engu-2.\n\nUkuze ushintshe phakathi kwezici, swayiphela phezulu ngeminwe engu-2 bese ubambe."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Swayiphela phezulu kusuka ezansi esikrinini ngeminwe engu-3.\n\nUkuze ushintshe phakathi kwezici, swayiphela phezulu ngeminwe engu-3 bese ubambe."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating" msgid="4459254227203203324"><annotation id="link">"Izinketho eziningi"</annotation></string>
    <string name="footer_learn_more_content_description" msgid="8843798273152131341">"Funda kabanzi nge-<xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Bamba okhiye bevolomu"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"bamba okhiye bevolomu"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Cindezela futhi ubambe bobabili okhiye bevolumu"</string>
    <string name="accessibility_shortcut_edit_dialog_title_two_finger_double_tap" msgid="2271778556854020996">"Isikrini othepha kabili ngeminwe emibili kuso"</string>
    <string name="accessibility_shortcut_two_finger_double_tap_keyword" msgid="2971265341474137433">"isikrini othepha kabili ngeminwe emibili kuso"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_two_finger_double_tap" msgid="8262165091808318538">"Thepha ngokushesha isikrini izikhathi ezingu-{0,number,integer} ngeminwe emibili"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Isikrini sokuthepha kathathu"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"isikrini sokuthepha kathathu"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="2102327956423320536">"Thepha ngokushesha isikrini izikhathi ezingu-{0,number,integer}. Lesi sinqamuleli singase sehlise isivinini sedivayisi yakho"</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Okuthuthukile"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"Inkinobho yokufinyelela isethelwe ku-<xliff:g id="SERVICE">%1$s</xliff:g>. Ukuze usebenzise ukushintsha, thinta futhi ubambe inkinobho yokufinyelela, bese ukhethe ukushintsha."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"Ukuthinta kokufinyelela kusethelwe ku-<xliff:g id="SERVICE">%1$s</xliff:g>. Ukuze usebenzise ukushintsha usayizi, swayiphela phezulu ngeminwe emibili kusuka phansi kwesikrini futhi ubambe. Bese khetha ukulungisa."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Isinqamuleli sokhiye wevolumu"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Izilungiselelo zesinqamuleli"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Isinqamuleki kusuka kusikrini sokukhiya"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Vumela isinqamuleli sesici ukuvula kusuka kusikrini sokukhiya. Bamba bobabili okhiye bevolumu amasekhondi ambalwa."</string>
    <string name="accessibility_button_title" msgid="5251235485581552614">"Inkinobho yokufinyeleleka"</string>
    <string name="accessibility_button_gesture_title" msgid="3573456209050374139">"Inkinobho yokufinyeleleka nokuthinta"</string>
    <string name="accessibility_button_intro_text" msgid="80993874471745687">"Finyelela ngokushesha izakhi zokufinyelela ezivela kunoma yisiphi isikrini"</string>
    <string name="accessibility_button_about_title" msgid="3581116105084067926">"Mayelana nenkinobho yokufinyeleleka"</string>
    <string name="accessibility_button_gesture_about_title" msgid="8468987303602865536">"Mayelana nenkinobho yokufinyeleleka nokuthinta"</string>
    <string name="accessibility_button_gesture_footer_learn_more_content_description" msgid="4144803517680297869">"Funda kabanzi ngenkinobho yokufinyeleleka nokuthinta"</string>
    <string name="accessibility_button_intro" msgid="2601976470525277903">"Ukusebenzisa inkinobho yokufinyeleleka. Ukuthinta akutholakali ngokuzulazula kwezinkinobho ezi-3."</string>
    <string name="accessibility_button_summary" msgid="8510939012631455831">"Finyelela ngokushesha izakhi zokufinyelela"</string>
    <string name="accessibility_button_gesture_description" msgid="1141723096904904336">"&lt;b&gt;Ukuze uqalise&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Iya kumasethingi okungena&lt;br/&gt; {1,number,integer}. Khetha isakhi bese uthepha isinqamuleli&lt;br/&gt; {2,number,integer}. Khetha ukuthi uyafuna yini ukusebenzisa inkinobho noma ukunyakazisa umzimba ukuze ufinyelele isakhi&lt;br/&gt;"</string>
    <string name="accessibility_button_description" msgid="7669538706120092399">"&lt;b&gt;Ukuze uqalise&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Iya kumasethingi okungena&lt;br/&gt; {1,number,integer}. Khetha isakhi bese uthepha isinqamuleli&lt;br/&gt; {2,number,integer}. Khetha inkinobho ukuze ufinyelele isakhi&lt;br/&gt;"</string>
    <string name="accessibility_button_or_gesture_title" msgid="3510075963401163529">"Sebenzisa inkinobho noma ukuthinta"</string>
    <string name="accessibility_button_location_title" msgid="7182107846092304942">"Indawo"</string>
    <string name="accessibility_button_size_title" msgid="5785110470538960881">"Usayizi"</string>
    <string name="accessibility_button_fade_title" msgid="8081993897680588829">"Iyafiphala uma ingasetshenziswa"</string>
    <string name="accessibility_button_fade_summary" msgid="7865950833524973709">"Iyafiphala ngemva kwamasekhondi ambalwa ukuze kube lula ukubona isikrini sakho"</string>
    <string name="accessibility_button_opacity_title" msgid="4727355657530362289">"Ibonisa ngale uma ingasetshenziswa"</string>
    <string name="accessibility_button_low_label" msgid="4193015407828927741">"Ibonisa ngale"</string>
    <string name="accessibility_button_high_label" msgid="9138077512008190896">"Ayibonisi ngale"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Umbala okhanya kakhulu"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Shintsha umbala wombhalo ube mnyama noma mhlophe. Khulisa ukugqama nengemuva."</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">"Buyekeza ngokuzenzakalela isisondezi-skrini"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Buyekeza isisondezi-skrini ekushintshweni kohlelo lokusebenza"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Inkinobho yamandla ivala ikholi"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Isikhombi esikhulu segundane"</string>
    <string name="accessibility_toggle_large_pointer_icon_summary" msgid="1480527946039237705">"Yenza isikhombi se-mouse sibonakale kakhudlwana"</string>
    <string name="accessibility_force_invert_title" msgid="5015366813138748407">"Yenza onke ama-app abe mnyama"</string>
    <string name="accessibility_force_invert_summary" msgid="1882329675950887268">"Isebenza kuma-app angenayo itimu yawo emnyama. Amanye ama-app angase abe nezinkinga zokubonisa, njengemibala engenisiwe."</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Susa ukugqwayiza"</string>
    <string name="accessibility_disable_animations_summary" msgid="5828228669556554565">"Yehlisa ukunyakaza esikrinini"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Umsindo we-Mono"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Hlanganisa iziteshi uma udlala umsindo"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Ukubhalansa umsindo"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Kwesokunxele"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Kwesokudla"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Okuzenzakalelayo"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"imizuzwana eyi-10"</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"30 amasekhondi"</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"1 iminithi"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 amaminithi"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Isikhathi sokwenza okuthile (Ukuphelelwa isikhathi kokufinyelela)"</string>
    <string name="accessibility_control_timeout_about_title" msgid="813588002683460837">"Isikhathi sokwenza okuthile (Ukuphelelwa isikhathi sokufinyeleleka)"</string>
    <string name="accessibility_control_timeout_footer_learn_more_content_description" msgid="8118584413220542193">"Funda kabanzi mayelana nesikhathi sokwenza okuthile (Ukuphelelwa isikhathi sokufinyeleleka)"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Isikhathi sokwenza isenzo"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="4037051091059316310">"Lokhu okuncanyelwayo kwesikhathi akusekelwa yiwo wonke ama-app"</string>
    <string name="accessibility_control_timeout_preference_intro_text" msgid="1398116710556762245">"Khetha ukuthi ungayibonisa isikhathi esingakanani imiyalezo yesikhashana ekucela ukuthi wenze okuthile"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Thinta futhi ukulibazisa"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Ukuguqulwa kombala"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Sebenzisa ukuguqulwa kombala"</string>
    <string name="accessibility_display_inversion_shortcut_title" msgid="6889624526691513462">"Isinqamuleli sokuguqulwa kombala"</string>
    <string name="accessibility_display_inversion_preference_intro_text" msgid="1159663288481145318">"Ukuguqulwa kombala kushintsha izikrini ezikhanyayo zibe mnyama. Kushintsha nezikrini ezimnyama zikhanye."</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="4494767676482389509">"&lt;b&gt;Khumbula&lt;/b&gt;&lt;br/&gt; &lt;ol&gt; &lt;li&gt; Imibala izoshintsha kumidiya nezithombeni&lt;/li&gt; &lt;li&gt; Ukuguqulwa kombala kusebenza kuwo wonke ama-app&lt;/li&gt; &lt;li&gt; Ukuze ubonise ingemuva elimnyama, kungasetshenziswa itimu emnyama esikhundleni salokho&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_action_label_panel_slice" msgid="1313725957071602932">"faka amasethingi"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Ukuchofoza ngokuzenzakalelayo (ukubalwa kwesikhathi kokuhlala)"</string>
    <string name="accessibility_autoclick_about_title" msgid="152923024405552594">"Mayelana nokuchofoza okuzenzekelayo (okunqunyelwe isikhathi kwe-dwell)"</string>
    <string name="accessibility_autoclick_footer_learn_more_content_description" msgid="7056189627042350691">"Funda kabanzi ngokuchfoza okuzenzekelayo (okunqunyelwe isikhathi kwe-dwell)"</string>
    <string name="accessibility_autoclick_intro_text" msgid="8959680635470639347">"Ungasetha imowusi exhunyiwe ukuthi ichofoze ngokuzenzakalelayo lapho i-cursor iyeka ukuhamba isikhathi esithile"</string>
    <string name="accessibility_autoclick_description" msgid="6695732131412361101">"Ukuchofoza okuzenzakalelayo kungaba usizo uma ukuchofoza imowusi kunzima"</string>
    <string name="accessibility_autoclick_default_title" msgid="2024730028293793490">"Ukuchofoza okuzenzakalelayo kuvaliwe"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Kufushane"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0.2 amasekhondi"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Maphakathi"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0.6 amasekhondi"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Kude"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"1 umzuzu"</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Ngokwezifiso"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Okufushane"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Okude nakakhulu"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Isikhathi sokuchofoza ngokuzenzakalelayo"</string>
    <string name="accessibility_vibration_settings_title" msgid="936301142478631993">"Ukudlidliza nama-haptic"</string>
    <string name="accessibility_vibration_settings_summary" msgid="3690308537483465527">"Lawula amandla wokudlidliza wokusetshenziswa okwehlukile"</string>
    <string name="accessibility_vibration_settings_state_on" msgid="5566026932372832502">"Vuliwe"</string>
    <string name="accessibility_vibration_settings_state_off" msgid="7946588741954981703">"Valiwe"</string>
    <string name="accessibility_vibration_setting_disabled_for_silent_mode_summary" msgid="3982701772953323190">"Ukusetha kukhutshaziwe ngoba idivayisi isethwe ukuthi ithule"</string>
    <string name="accessibility_call_vibration_category_title" msgid="2545607568768192318">"Amakholi"</string>
    <string name="accessibility_notification_alarm_vibration_category_title" msgid="2683635252414849417">"Izaziso nama-alamu"</string>
    <string name="accessibility_interactive_haptics_category_title" msgid="3162855291184592021">"Ama-haptic asebenzisanayo"</string>
    <string name="accessibility_vibration_primary_switch_title" msgid="6162579254864450592">"Sebenzisa ukudlidliza nama-haptic"</string>
    <string name="accessibility_alarm_vibration_title" msgid="4661294337828522745">"Ukudlidliza kwe-alamu"</string>
    <string name="accessibility_media_vibration_title" msgid="1372073715403945428">"Ukudlidliza kwemidiya"</string>
    <string name="accessibility_keyboard_vibration_title" msgid="7559967730626765441">"Ukudlidliza kwekhibhodi"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Ukudlidliza kokukhala"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Ukudlidliza kwesaziso"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Impendulo yokuthinta"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"Sebenzisa i-<xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"Vula i-<xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_auto_added_qs_tooltip_content" msgid="2941824314912928072">"I-<xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> ingezwe Kumasethingi Asheshayo. Swayiphela phansi ukuze uyivule noma uyivale noma kunini."</string>
    <string name="accessibility_service_qs_tooltip_content" msgid="6002493441414967868">"Ungangeza ne-<xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> Kumasethingi Asheshayo kusukela phezulu esikrinini sakho"</string>
    <string name="accessibility_color_correction_auto_added_qs_tooltip_content" msgid="9092661358437404374">"Ukulungiswa kombala kwengezwe kokuthi Amasethingi Azisheshayo. Swayiphela phansi ukuze uyivule noma uyivale noma kunini."</string>
    <string name="accessibility_color_correction_qs_tooltip_content" msgid="3258628434235475205">"Ungakwazi futhi ukwengeza ukulungiswa kombala kokuthi Amasethingi Asheshayo kusukela phezulu esikrinini sakho"</string>
    <string name="accessibility_color_inversion_auto_added_qs_tooltip_content" msgid="7267618234972101725">"Ukuguqulwa kombala kwengezwe kokuthi Amasethingi Asheshayo. Swayiphela phansi ukuze uyivule noma uyivale noma kunini."</string>
    <string name="accessibility_color_inversion_qs_tooltip_content" msgid="5046332142185711869">"Ungakwazi futhi ukwengeza ukuguqulwa kombala kokuthi Amasethingi Asheshayo kusukela phezulu esikrinini sakho"</string>
    <string name="accessibility_reduce_bright_colors_auto_added_qs_tooltip_content" msgid="1906588335786328512">"Ukufiphala okwengeziwe kwengezwe kokuthi Amasethingi Asheshayo. Swayiphela phansi ukuze uyivule noma uyivale noma kunini."</string>
    <string name="accessibility_reduce_bright_colors_qs_tooltip_content" msgid="7522121299176176785">"Ungakwazi futhi ukwengeza ukufiphala okwengeziwe kokuthi Amasethingi Asheshayo kusukela phezulu esikrinini sakho"</string>
    <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content" msgid="7914554254280416532">"Imodi yesandla esisodwa yengezwe kokuthi Amasethingi Asheshayo. Swayiphela phansi ukuze uyivule noma uyivale noma kunini."</string>
    <string name="accessibility_one_handed_mode_qs_tooltip_content" msgid="2754332083184384603">"Ungakwazi futhi ukwengeza imodi yesandla esisodwa kokuthi Amasethingi Asheshayo kusukela phezulu esikrinini sakho"</string>
    <string name="accessibility_font_scaling_auto_added_qs_tooltip_content" msgid="7229921960884718332">"Usayizi wefonti wengezwe Kumasethingi Asheshayo. Swayiphela phansi ukuze ushintshe usayizi wefonti noma nini."</string>
    <string name="accessibility_quick_settings_tooltip_dismiss" msgid="3269120277643884190">"Chitha"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Sebenzisa ukulungisa kombala"</string>
    <string name="accessibility_daltonizer_shortcut_title" msgid="7480360363995502369">"Isinqamuleli sokulungiswa kombala"</string>
    <string name="accessibility_daltonizer_about_title" msgid="6063650804116981287">"Mayelana nokulungiswa kombala"</string>
    <string name="accessibility_daltonizer_footer_learn_more_content_description" msgid="2091679253892040910">"Funda kabanzi mayelana nokulungiswa kombala"</string>
    <string name="accessibility_color_inversion_about_title" msgid="8275754480247040136">"Mayelana nokuguqulwa kombala"</string>
    <string name="accessibility_color_inversion_footer_learn_more_content_description" msgid="5382579548498952445">"Funda kabanzi ngokuguqulwa kombala"</string>
    <string name="accessibility_captioning_primary_switch_title" msgid="3663677340286206100">"Bonisa amagama-ncazo"</string>
    <string name="accessibility_captioning_primary_switch_summary" msgid="2544094070306830218">"Ngokwe-app esekelwe kuphela"</string>
    <string name="captioning_appearance_title" msgid="3128792092290011408">"Usayizi nesitayela samagama-ncazo"</string>
    <string name="captioning_appearance_summary" msgid="4620682807315588019">"<xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g> usayizi wombhalo"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Ezinye izinketho"</string>
    <string name="accessibility_captioning_preference_intro" msgid="8995427146374031134">"Enza ngendlela oyifisayo usayizi wegama-ncazo nesitayela ukuze kufundeke kalula"</string>
    <string name="accessibility_captioning_preference_summary" msgid="8335768472978374255">"Lokhu okuncanyelwayo kwegama-ncazo akusekelwa yiwo wonke ama-app wemidiya"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Inkinobho yokufinyeleleka"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"Ukuswayipha kweminwe emibili kusuka phansi"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Bamba okhiye bevolomu"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Isikrini sokuthepha kathathu"</string>
    <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Hlela izinqamuleli zokufinyeleleka"</string>
    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
    <skip />
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Qhubeka"</string>
    <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Amadivayizi okuzwa"</string>
    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
    <skip />
    <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Azikho izinsizakuzwa ezixhunyiwe"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Engeza izinsinza zokuzwa"</string>
    <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Bhangqa imishini yendlebe"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="581652489109350119">"Esikrinini esilandelayo, thepha imishini yakho yendlebe. Kungase kudingeke ukuthi ubhangqe izindlebe zakho ezingakwesokunxele nesokudla ngokwehlukile.\n\nQiniseka ukuthi imishini yakho yendlebe ivuliwe futhi ikulungele ukubhangqa."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> iyasebenza"</string>
    <string name="accessibility_hearingaid_left_side_device_summary" msgid="1907302799168261001">"I-<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, ngakwesokunxele kuphela"</string>
    <string name="accessibility_hearingaid_right_side_device_summary" msgid="148257064855054376">"I-<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, ngakwesokudla kuphela"</string>
    <string name="accessibility_hearingaid_left_and_right_side_device_summary" msgid="4268221140368164452">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, okungakwesokunxele nesokudla"</string>
    <string name="accessibility_hearingaid_more_device_summary" msgid="8092641784056942546">"I-<xliff:g id="DEVICE_NAME">%1$s</xliff:g> +1 okuningi"</string>
    <string name="accessibility_hearing_device_pairing_title" msgid="2701812183769537320">"Bhangqa idivayisi entsha"</string>
    <string name="accessibility_hearing_device_connected_title" msgid="3785140037249487287">"Amadivayizi okuzwa"</string>
    <string name="accessibility_hearing_device_saved_title" msgid="7573926212664909296">"Amadivayisi alondoloziwe"</string>
    <string name="accessibility_hearing_device_control" msgid="2661965917013100611">"Izilawuli zedivayisi yokuzwa"</string>
    <string name="accessibility_hearing_device_shortcut_title" msgid="7645100199603031360">"Isinqamuleli sedivayisi yokuzwa"</string>
    <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Ukusebenzisana nensiza yokuzwa"</string>
    <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Ithuthukisa ukuhambisana nama-telecoil futhi inciphisa umsindo ongafuneki"</string>
    <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Mayelana nemishini yokuzwa"</string>
    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
    <skip />
    <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Bhanqa idivayisi yokuzwa"</string>
    <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Ungabhangqa amadivayisi okuzwa e-ASHA ne-LE Audio kuleli khasi. Qinisekisa ukuthi idivayisi yakho yokuzwa ivuliwe futhi ilungele ukubhanqa."</string>
    <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Amadivayisi okuzwa atholakalayo"</string>
    <string name="accessibility_found_all_devices" msgid="7817834722148556520">"Awuyiboni idivayisi yakho yokuzwa?"</string>
    <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"Bona amadivayisi amaningi"</string>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Ukulungiswa komsindo"</string>
    <string name="accessibility_toggle_audio_description_preference_title" msgid="8916473886256061220">"Incazelo yokulalelwayo"</string>
    <string name="accessibility_audio_description_summary" msgid="2554789094873781056">"Izwa incazelo yalokho okwenzeka esikrinini kumamuvi nezinhlelo ezisekelwayo"</string>
    <string name="keywords_audio_description" msgid="6202816411593281252">"incazelo yokulalelwayo, incazelo yokulalelwayo, amehlo aluvindi,"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Isinqamuleli sivuliwe"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Valiwe"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"Vuliwe"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Valiwe"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Akusebenzi. Thepha ukuze uthole ulwazi."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Le sevisi ayisebenzi kahle."</string>
    <string name="accessibility_shortcuts_settings_title" msgid="974740249671825145">"Izinqamuleli zokufinyeleleka"</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Bonisa Kuzilungiselelo Ezisheshayo"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="4210949400493358650">"Okubomvu-okuluhlaza okotshani"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6392456967103014723">"Okubomvu-okuluhlaza okotshani"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="2278786218762602022">"Okuluhlaza okwesibhakabhaka-okuphuzi"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"I-grayscale"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="2117727423019598455">"Okuluhlaza okotshani okubuthakathaka, i-deuteranomaly"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="4617032854982040748">"Okubomvu okubuthakathaka, i-protanomaly"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2428218320118180070">"I-Tritanomaly"</string>
    <string name="reduce_bright_colors_preference_title" msgid="2249314004651574997">"Ukufiphaza okwengeziwe"</string>
    <string name="reduce_bright_colors_switch_title" msgid="1751678397884065312">"Fiphaza isikrini sakho ngokwengeziwe"</string>
    <string name="reduce_bright_colors_shortcut_title" msgid="495648157059202745">"Isinqamuleli sokufiphaza okwengeziwe"</string>
    <string name="reduce_bright_colors_about_title" msgid="503655452544934393">"Mayelana nokufiphaza okwengeziwe"</string>
    <string name="reduce_bright_colors_preference_intro_text" msgid="3502290826747650566">"Yenza isikrini sakho sifiphale ukuze kube lula ukufunda"</string>
    <string name="reduce_bright_colors_intensity_preference_title" msgid="7455443033955118267">"Ukuqina"</string>
    <string name="reduce_bright_colors_intensity_start_label" msgid="930387498396426039">"Ukufiphala"</string>
    <string name="reduce_bright_colors_intensity_end_label" msgid="1422600205484299860">"Ukukhanya"</string>
    <string name="reduce_bright_colors_persist_preference_title" msgid="4368829654993343354">"Gcina kuvuliwe ngemva kokuthi idivayisi iqalise kabusha"</string>
    <string name="accessibilty_autoclick_preference_subtitle_short_delay" msgid="2981206111858937724">"{count,plural, =1{Imfushane ({time} isekhondi)}one{Imfushane ({time} amasekhondi)}other{Imfushane ({time} amasekhondi)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_medium_delay" msgid="6867395206533459204">"{count,plural, =1{Phakathi nendawo ({time} isekhondi)}one{Phakathi nendawo ({time} amasekhondi)}other{Phakathi nendawo ({time} amasekhondi)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_long_delay" msgid="4079139970819335593">"{count,plural, =1{Yinde ({time} isekhondi)}one{Yinde ({time} amasekhondi)}other{Yinde ({time} amasekhondi)}}"</string>
    <string name="accessibilty_autoclick_delay_unit_second" msgid="5979297390686370567">"{count,plural, =1{{time} isekhondi}one{imizuzwana engu-{time}}other{imizuzwana engu-{time}}}"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Izilungiselelo"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"Vuliwe"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Kucishile"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Buka kuqala"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Izinketho ezijwayelekile"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Ulimi"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Usayizi wombhalo"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Isitayela segama-ncazo"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Izinketho ezingokwezifiso"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Umbala ongemuva"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Ukufiphala kwangemuva"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Umbala wewindi lamagama-ncazo"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"I-Opacity yewindi lamagama-ncazo"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Umbala wombhalo"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"I-Opacity yombhalo"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Umbala wonqenqema"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Uhlobo lonqenqema"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"I-Font Family"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Amazwibela azobukeka ngale ndlela"</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Okuzenzakalelayo"</string>
    <string name="color_title" msgid="2511586788643787427">"Umbala"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Okuzenzakalelayo"</string>
    <string name="color_none" msgid="3703632796520710651">"Lutho"</string>
    <string name="color_white" msgid="1896703263492828323">"Okumhlophe"</string>
    <string name="color_gray" msgid="8554077329905747877">"Okumpunga"</string>
    <string name="color_black" msgid="9006830401670410387">"Okumnyama"</string>
    <string name="color_red" msgid="5210756997426500693">"Okubomvu"</string>
    <string name="color_green" msgid="4400462091250882271">"Okuluhlaza okotshani"</string>
    <string name="color_blue" msgid="4997784644979140261">"Okuluhlaza okwesibhakabhaka"</string>
    <string name="color_cyan" msgid="4341758639597035927">"I-Cyan"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Okuliphuzi"</string>
    <string name="color_magenta" msgid="8943538189219528423">"I-Magenta"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"Vumela i-<xliff:g id="SERVICE">%1$s</xliff:g> ukuthola ukulawula okuphelele kwedivayisi yakho?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"<xliff:g id="SERVICE">%1$s</xliff:g> idinga :"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Ngoba uhlelo lokusebenza lusitha isicelo semvume, Izilungiselelo azikwazi ukuqinisekisa impendulo yakho."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"<xliff:g id="SERVICE">%1$s</xliff:g> icela ukulawula okuphelele kwale divayisi. Isevisi ingafunda isikrini futhi isebenze engxenyeni yabasebenzisi abanezidingo zokufinyelela. Le leveli yokulawula ayiqondile kuzinhlelo zokusebenza eziningi."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"Ukulawula okugcwele kulungele izinhlelo zokusebenza ezikusiza ngezidingo zokufinyelela, kodwa hhayi izinhlelo zokusebenza eziningi."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Buka futhi ulawule isikrini"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"Singafunda konke okuqukethwe esikrinini futhi sibonise okuqukethwe kwezinye izinhlelo zokusebenza."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Buka uphinde wenze izenzo"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"Ingalandela ukusebenzisana kwakho nohlelo lokusebenza noma inzwa yehadiwe, nokusebenzisana nezinhlelo zokusebenza engxenyeni yakho."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Vumela"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Phika"</string>
    <string name="accessibility_dialog_button_stop" msgid="7584815613743292151">"Vala"</string>
    <string name="accessibility_dialog_button_cancel" msgid="8625997437316659966">"Qhubeka"</string>
    <string name="disable_service_title" msgid="8178020230162342801">"Vala i-<xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"Ayikho isevisi efakiwe"</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"Ayikho isevisi ekhethiwe"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"Akukho ncazelo enikeziwe."</string>
    <string name="settings_button" msgid="2195468788019730377">"Izilungiselelo"</string>
    <string name="keywords_reduce_bright_colors" msgid="1683190961013139183">"ukuzwela kokukhanya, ukwesaba izithombe, itimu emnyama, i-migraine, ikhanda elibuhlungu, imodi yokufunda, imodi yasebusuku, nciphisa ukukhanya, iphoyinti elimhlophe"</string>
    <string name="keywords_accessibility" msgid="8593989878379366798">"ukubuka, ukuzwa, impumputhe, isithuli, imoto, i-dexterity, okusizayo, usizo, ukusebenziseka kalula, ukufinyelela kalula, isandla, usizo"</string>
    <string name="keywords_magnification" msgid="3908145308269840862">"Isikhulisi Sewindi, Sondeza, Ukukhuliswa, Amehlo aluvindi, Khulisa, yenza kube kukhulu"</string>
    <string name="keywords_talkback" msgid="2816435437095102527"></string>
    <string name="keywords_live_caption" msgid="1667203998080567556">"Amagama-ncazo, amazwibela avaliwe, i-CC, i-Live Transcribe, inkinga yokuzwa, ukulahleka kokuzwa, UBHASKIDI, inkulumo eya kumbhalo, umbhalo ongezansi"</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">"usayizi wesikrini, isikrini esikhulu"</string>
    <string name="keywords_bold_text" msgid="6257418169207099589">"Ukubukeka kwezinga eliphezulu, amehlo aluvindi, ifonti egqamile, ubuso obugqamile"</string>
    <string name="keywords_select_to_speak" msgid="2872704811610888719"></string>
    <string name="keywords_color_correction" msgid="8540442886990423681">"lungisa umbala"</string>
    <string name="keywords_color_inversion" msgid="4291058365873221962">"yenza isikrini sibe myama, yenza isikrini sikhanye"</string>
    <string name="keywords_contrast" msgid="4668393735398949873">"ukungafani kombala"</string>
    <string name="keywords_accessibility_menu" msgid="4300579436464706608"></string>
    <string name="keywords_switch_access" msgid="5813094504384313402"></string>
    <string name="keywords_auto_click" msgid="6811744211216280998">"imoto, i-mouse, i-mouse yangaphandle, i-mouse eyinhloko, i-mouse evumelana, isihlalo sabakhubazekile, i-joystick"</string>
    <string name="keywords_hearing_aids" msgid="4657889873249157071">"imishini yendlebe, onenkinga yokuzwa, ukulahlekelwa ukuzwa, izifakelo ze-cochlear, amadivaysi okukhulisa umsindo, izicubunguli zomsindo, i-PSAP"</string>
    <string name="keywords_rtt" msgid="2429130928152514402">"onenkinga yokuzwa, ukulahlekelwa ukuzwa, amagama-ncazo, i-Teletype, i-tty"</string>
    <string name="keywords_voice_access" msgid="7807335263195876454"></string>
    <string name="keywords_3_button_navigation" msgid="436361965016404218">"izinkinobho ezintathu"</string>
    <string name="keywords_touch_and_hold_delay" msgid="7854640156419599912">"i-dexterity, imoto, umuntu omdala, isifo samathambo, i-rsi, ukufa kohlangothi, idumbe, i-multiple sclerosis, i-cerebral palsy, ukuqhaqhazela, ukulimala kokucindezeleka okuphindayo, isandla"</string>
    <string name="keywords_accessibility_timeout" msgid="8903766864902000346">"ukubambezeleka, i-dexterity, abantu abadala"</string>
    <string name="print_settings" msgid="8519810615863882491">"Ukuphrinta"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Kuvaliwe"</string>
    <string name="print_settings_summary" msgid="1458773840720811915">"{count,plural, =1{Isevisi e-1 yephrinta ivulekile}one{Amasevisi angu-# ephrinta avulekile}other{Amasevisi angu-# ephrinta avulekile}}"</string>
    <string name="print_jobs_summary" msgid="7040836482336577323">"{count,plural, =1{Umsebenzi wokuphrinta o-1}one{Imisebenzi yokuphrinta engu-#}other{Imisebenzi yokuphrinta engu-#}}"</string>
    <string name="print_settings_title" msgid="7680498284751129935">"Amasevisi wokuphrinta"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"Awekho amasevisi afakiwe"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"Awekho amaphrinta atholiwe"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Izilungiselelo"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Engeza amaphrinta"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"Vuliwe"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Valiwe"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Engeza isevisi"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Engeza iphrinta"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Sesha"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Isesha amaphrinta"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Isevisi ikhutshaziwe"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Imisebenzi yokuphrinta"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Umsebenzi wokuphrinta"</string>
    <string name="print_restart" msgid="4424096106141083945">"Qala kabusha"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Khansela"</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">"Ilungiselela i-<xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"Iphrinta i-<xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"Ikhansela i-<xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Iphutha lephrinta ye-<xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"Iphrinta engu-<xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> ivinjelwe"</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Ibhokisi lokuhlola libonisiwe"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Ibhokisi lokusesha lifihliwe"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Olunye ulwazi mayelana nale phrinta"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Ibhethri"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Yini ekade isebenzisa ibhethri"</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> osele"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> ukuze lishajiwe"</string>
    <string name="power_usage_detail_screen_time" msgid="6027274749498485283">"Isikhathi sesikrini"</string>
    <string name="power_usage_detail_background_time" msgid="3661437083554322691">"Isikhathi sangemuva"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Ibhethri liphansi"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Vumela uhlelo lokusebenza ukuthi lusebenze ngemuva"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Khawulela umsebenzi wasemuva?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"Uma ukhawulela umsebenzi wangasemuva wohlelo lokusebenza, lungahle lungasebenzi kahle"</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Njengoba lolu hlelo lokusebenza lungasethiwe ukuze kulungiselelwe ibhethri, awukwazi ukulikhawulela.\n\nUkuze ukhawulele uhlelo lokusebenza, qala uvule ukulungiselelwa kwebhethri."</string>
    <string name="manager_battery_usage_category_title" msgid="1493303237531629961">"Phatha ukusetshenziswa kwebhethri"</string>
    <string name="manager_battery_usage_allow_background_usage_title" msgid="6294649996820358852">"Vumela ukusetshenziswa kwengemuva"</string>
    <string name="manager_battery_usage_allow_background_usage_summary" msgid="8021153755201340819">"Nika amandla ezibuyekezweni zesikhathi sangempela, khubaza ukuze wonge amandla"</string>
    <string name="manager_battery_usage_unrestricted_title" msgid="2426486290463258032">"Akunamkhawulo"</string>
    <string name="manager_battery_usage_optimized_title" msgid="8080765739761921817">"Kulungisiwe"</string>
    <string name="manager_battery_usage_restricted_title" msgid="7702863764130323118">"Kuvinjelwe"</string>
    <string name="manager_battery_usage_unrestricted_summary" msgid="6819279865465667692">"Vumela ukusetshenziswa kwebhethri ngemuva ngaphandle kwemikhawulo. Ingase isebenzise ibhethri eliningi."</string>
    <string name="manager_battery_usage_optimized_summary" msgid="1332545476428039900">"Simamisa ngokususelwe ekusetshenzisweni kwakho. Kunconyelwa ama-app amaningi."</string>
    <string name="manager_battery_usage_restricted_summary" msgid="8324695640704416905">"Khawulela ukusetshenziswa kwebhethri ngenkathi kungemuva. I-app ingase ingasebenzi njengokulindelekile. Izaziso zingase ziphazanyiswe."</string>
    <string name="manager_battery_usage_footer" msgid="2635906573922553766">"Ukushintsha indlela i-app esebenzisa ngayo ibhethri kungathinta ukusebenza kwayo."</string>
    <string name="manager_battery_usage_footer_limited" msgid="5180776148877306780">"Le app idinga ukusetshenziswa kwebhethri okungu-<xliff:g id="STATE">%1$s</xliff:g>."</string>
    <string name="manager_battery_usage_unrestricted_only" msgid="3646162131339418216">"akunamkhawulo"</string>
    <string name="manager_battery_usage_optimized_only" msgid="7121785281913056432">"kulungiselelwe"</string>
    <string name="manager_battery_usage_link_a11y" msgid="374918091821438564">"Funda kabanzi ngezinketho zokusetshenziswa kwebhethri"</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Ukusebenzisa kwesikrini kusuka ekushajeni okuphelele"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Ukusetshenziswa kwebhethri"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Imininingwane yomlando"</string>
    <string name="advanced_battery_preference_title" msgid="3790901207877260883">"Ukusetshenziswa kwebhethri"</string>
    <string name="advanced_battery_preference_summary_with_hours" msgid="954091349133320955">"Buka ukusetshenziswa kwamahora angama-24 edlule"</string>
    <string name="advanced_battery_preference_summary" msgid="2372763700477268393">"Buka ukusetshenziswa kusuka ekushajeni okugcwele kokugcina"</string>
    <string name="battery_details_title" msgid="3289680399291090588">"Ukusetshenziswa kwebhethri yi-app"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Sebenzisa imininingwane"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Lungisa amandla okusebenza"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Amaphakheji ahlanganisiwe"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Izinhlelo zokusebenza zisebenza ngokujwayelekile"</string>
    <string name="battery_tip_low_battery_title" msgid="4155239078744100997">"Ileveli yebhethri iphansi"</string>
    <string name="battery_tip_low_battery_summary" msgid="2629633757244297436">"Vula Isilondolozi Sebhethri ukuze unwebe impilo yebhethri"</string>
    <string name="battery_tip_smart_battery_title" msgid="8925025450214912325">"Thuthukisa impilo yebhethri"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Vula isiphathi sebhethri"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Vula isilondolozi sebhethri"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"Ibhethri lingaphela ngaphambi kwesikhathi kunokujwayelekile"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="7705597228709143337">"Isilondolozi Sebhethri sivuliwe"</string>
    <string name="battery_saver_link_a11y" msgid="6613079613524512257">"Funda kabanzi Ngesilondolozi Sebhethri"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Ezinye izici zingakhawulelwa"</string>
    <string name="battery_tip_high_usage_title" msgid="9110720762506146697">"Ukusetshenziswa kakhulu kwebhethri"</string>
    <string name="battery_tip_high_usage_summary" msgid="3938999581403084551">"Bona ama-app asetshenziswa kakhulu"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="6258554134146272311">"Ukushaja kuthuthukisiwe ukuvikela ibhethri lakho"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="5107379280241187562">"Ukusiza ukunweba impilo yebhethri yakho, ukushaja kuthuthukisiwe"</string>
    <string name="battery_tip_limited_temporarily_sec_button_content_description" msgid="5648444926736883551">"Funda kabanzi mayelana nokuthi ukushaja kumisiwe"</string>
    <string name="battery_tip_limited_temporarily_dialog_resume_charge" msgid="2302295458913832342">"Qalisa kabusha ukukhokhisa"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Ifaka umsebenzi ongemuva wamandla aphezulu"</string>
    <string name="battery_tip_restrict_title" msgid="4537101947310626753">"{count,plural, =1{Khawulela i-app engu-#}one{Khawulela ama-app angu-#}other{Khawulela ama-app angu-#}}"</string>
    <string name="battery_tip_restrict_handled_title" msgid="7142074986508706853">"{count,plural, =1{I-{label} isanda kukhawulelwa}one{Ama-app angu-# asanda kukhawulelwa}other{Ama-app angu-# asanda kukhawulelwa}}"</string>
    <string name="battery_tip_restrict_summary" msgid="7539469590829235277">"{count,plural, =1{I-{label} inokusetshenziswa kwebhethri okuphakeme kwangemuva}one{Ama-app angu-# anokusetshenziswa kwebhethri okuphakeme kwangemuva}other{Ama-app angu-# anokusetshenziswa kwebhethri okuphakeme kwangemuva}}"</string>
    <string name="battery_tip_restrict_handled_summary" msgid="3535697154547199190">"{count,plural, =1{Le app ayikwazi ukusebenza ngemuva}one{Lama-app awakwazi ukusebenza ngemuva}other{Lama-app awakwazi ukusebenza ngemuva}}"</string>
    <string name="battery_tip_restrict_app_dialog_title" msgid="1649476357343160240">"{count,plural, =1{Khawulela i-app?}one{Khawulela ama-app angu-#?}other{Khawulela ama-app angu-#?}}"</string>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"Ukuze ulondoloze ibhethri, misa i-<xliff:g id="APP">%1$s</xliff:g> kusukela ekusebenziseni ibhethri ngemuva. Lolu hlelo lokusebenza kungenzeka lingasebenzi kahle futhi izaziso zingalitshaziswa."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"Ukuze kulondolozwe ibhethri, misa lezi zinhlelo zokusebenza kusukela ekusebenziseni ibhethri ngemuva. Izinhlelo zokusebenza ezikhawulelwe kungenzeka zingasebenzi kahle futhi izaziso zingalibaziseka.\n\nIzinhlelo zokusebenza:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"Ukuze kulondolozwe ibhethri, misa lezi zinhlelo zokusebenza kusukela ekusebenziseni ibhethri ngemuva. Izinhlelo zokusebenza ezikhawulelwe kungenzeka zingasebenzi kahle futhi izaziso kungenzeka zilibaziseke.\n\nIzinhlelo zokusebenza:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Khawulela"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Susa ukukhawulelwa?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"Lolu hlelo lokusebenza luzokwazi ukusebenzisa ibhethri ngemuva. Ibhethri lakho lingaphela ngokushesha kunokulindelekile."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Susa"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Khansela"</string>
    <string name="battery_tip_charge_to_full_button" msgid="9172893341338732733">"Khipha"</string>
    <string name="battery_tip_incompatible_charging_title" msgid="1567827436103364999">"Hlola insiza yokushaja"</string>
    <string name="battery_tip_incompatible_charging_content_description" msgid="355668467640367701">"Funda kabanzi mayelana nokushaja okungahambelani"</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Isiphathi sebhethri"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Phatha izinhlelo zokusebenza ngokuzenzakalela"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Uma isiphathi sebhethri sithola ukuthi izinhlelo zokusebenza zidonsa ibhethri, uzoba nenketho yokukhawulela lezi zinhlelo zokusebenza. Izinhlelo zokusebenza ezikhawulelwe kungenzeka zingasebenzi kahle futhi izaziso kungenzeka zilibaziseke."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Izinhlelo zokusebenza ezikhawulelwe"</string>
    <string name="restricted_app_summary" msgid="1022307922754893997">"{count,plural, =1{Ukukhawulela ukusetshenziswa kwebhethri kwe-app engu-#}one{Ukukhawulela ukusetshenziswa kwebhethri kwama-app angu-#}other{Ukukhawulela ukusetshenziswa kwebhethri kwama-app angu-#}}"</string>
    <string name="restricted_app_time_summary" msgid="3097721884155913252">"Kukhawulelwe ngo-<xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="3495725286882138803">"Lawa ma-app akhawulelwe ekusebenziseni ibhethri ngasemuva. Angahle angasebenzi njengoba bekulindelwe, futhi izaziso zingabambezeleka."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Sebenzisa isiphathi sebhethri"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Iyathola uma izinhlelo zokusebenza zidonsa ibhethri"</string>
    <string name="battery_manager_summary" msgid="255708681438809287">"Ukuthola uma ama-app adonsa ibhethri"</string>
    <string name="battery_manager_summary_unsupported" msgid="7334173707292807964">"Ukuthola uma ama-app adonsa ibhethri"</string>
    <string name="battery_manager_app_restricted" msgid="2583902700677009173">"{count,plural, =1{I-app engu-# ikhawulelwe}one{Ama-app angu-# akhawulelwe}other{Ama-app angu-# akhawulelwe}}"</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">"Inkinga yokufunda imitha yebhethri."</string>
    <string name="battery_missing_link_message" msgid="6021565067124898074"></string>
    <string name="battery_missing_link_a11y_message" msgid="3310971406602316323">"Thepha ukuze ufunde kabanzi ngaleli phutha"</string>
    <string name="power_screen" msgid="4596900105850963806">"Isikrini"</string>
    <string name="power_cpu" msgid="1820472721627148746">"I-CPU"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"I-Flashlight"</string>
    <string name="power_camera" msgid="4778315081581293923">"Ikhamera"</string>
    <string name="power_gps" msgid="6352380895542498164">"I-GPS"</string>
    <string name="power_wifi" msgid="4614007837288250325">"I-Wi-Fi"</string>
    <string name="power_bluetooth" msgid="5085900180846238196">"I-Bluetooth"</string>
    <string name="power_cell" msgid="7793805106954398186">"Inethiwekhi yeselula"</string>
    <string name="power_phone" msgid="2768396619208561670">"Amakholi ezwi"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Ukusetshenziswa kwesikrini <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<xliff:g id="PERCENT">%1$s</xliff:g> kusetshenziswe yi-<xliff:g id="APP">%2$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> kwalo lonke ibhethri"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Ukwaphuka kusuka ekushajeni okuphelele"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Ukushija okuphelele kokugcina"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"Ukushaja okugcwele kuhlala cishe okungu-"</string>
    <string name="battery_footer_summary" msgid="6753248007004259000">"Isikhathi esisele sebhethri siyalinganiselwa futhi singashintsha ngokusekelwe ekusetshenzisweni"</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Ukusetshenziswa kwebhethri"</string>
    <string name="battery_not_usage" msgid="3851536644733662392">"Akukho ukusetshenziswa kusuka ekushajweni okugcwele kokugcina"</string>
    <string name="battery_not_usage_24hr" msgid="8397519536160741248">"Akusetshenziswanga emahoreni angama-24 adlule"</string>
    <string name="battery_usage_without_time" msgid="1346894834339420538"></string>
    <string name="battery_usage_since_last_full_charge" msgid="3488425008925924769">"kusukela ekushajeni okugcwele kokugcina"</string>
    <string name="battery_usage_system_apps" msgid="8659537819731575299">"I-app yesistimu"</string>
    <string name="battery_usage_uninstalled_apps" msgid="8170405012552803662">"Ama-app akhishiwe"</string>
    <string name="battery_usage_others" msgid="311793281613609986">"Abanye"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Isikhathi esilinganiselwe esisele"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Kuze kushaje ngokuphelele"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"Ukulinganisa kungashintsha ngokuya ngokusebenzisa"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Iseva yemidiya"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Ukuthuthukisa kohlelo lokusebenza"</string>
    <string name="process_network_tethering" msgid="6822671758152900766">"Ukusebenzisa ifoni njengemodemu"</string>
    <string name="process_removed_apps" msgid="6544406592678476902">"Ama-app asusiwe"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Isilondolozi sebhethri"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Vula ngokuzenzakalela"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Ayikho ishejuli"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Ngokususelwe kumzila wakho"</string>
    <string name="battery_saver_pref_auto_routine_summary" msgid="4739240095966241508">"Izovulwa ngokusekelwe kumjikelezo wakho"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Ngokususelwe kuphesenti"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Isilondolozi sebhethri siyavula uma ibhethri lingaphela ngaphambi kokushaja kwakho okuvamile"</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Izovuleka ku-<xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Setha ishejuli"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Khulisa impilo yebhethri"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Vala lapho ishajiwe"</string>
    <string name="battery_saver_sticky_title_percentage" msgid="1178162022087559148">"Vala ku-<xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" msgid="6472610662679038342">"Isilondolozi Sebhethri siyavalwa lapho ibhethri lifika ku-<xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <!-- no translation found for battery_saver_seekbar_title (3712266470054006641) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="7141264642540687540">"Vula"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Sebenzisa isilondolozi sebhethri"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Vula ngokuzenzakalela"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Akusoze"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"kokungu-<xliff:g id="PERCENT">%1$s</xliff:g> kubhethri"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Amaphesenti ebhethri"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Bonisa amaphesenti ebhethri kubha yesimo"</string>
    <string name="battery_usage_chart_graph_hint_last_full_charge" msgid="6570336408060566877">"Ileveli yebhethri ukusukela ekushajweni kokugcina okugcwele"</string>
    <string name="battery_usage_chart_graph_hint" msgid="9182079098173323005">"Ileveli yebhethri emahoreni angama-24 adlule"</string>
    <string name="battery_app_usage" msgid="8976453608783133770">"Ukusetshenziswa kwe-app ukusukela ekushajweni kokugcina okugcwele"</string>
    <string name="battery_app_usage_for_past_24" msgid="1234770810563940656">"Ukusetshenziswa kwe-app emahoreni angama-24 adlule"</string>
    <string name="battery_system_usage" msgid="1395943945140097585">"Ukusetshenziswa kwesistimu ukusukela ekushajweni kokugcina okugcwele"</string>
    <string name="battery_system_usage_for_past_24" msgid="3341520273114616263">"Ukusetshenziswa kwesistimu emahoreni angama-24 adlule"</string>
    <string name="battery_system_usage_for" msgid="3248552137819897140">"Ukusetshenziswa kwesistimu nge-<xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_app_usage_for" msgid="7309909074935858949">"Ukusetshenziswa kwe-app nge-<xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_system_usage_since_last_full_charge_to" msgid="4196795733829841971">"Ukusetshenziswa kwesistimu ukusukela ekushajeni okugcwele ukuya ku-<xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_app_usage_since_last_full_charge_to" msgid="4339201995118102114">"Ukusetshenziswa kwe-app ukusukela ekushajeni okugcwele ukuya ku-<xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_usage_total_less_than_one_minute" msgid="1035425863251685509">"Ingqikithi: ngaphansi komzuzu"</string>
    <string name="battery_usage_background_less_than_one_minute" msgid="3957971442554437909">"Ingemuva: ngaphansi komzuzu"</string>
    <string name="battery_usage_screen_time_less_than_one_minute" msgid="2911989465891679033">"Isikhathi sesikrini: ngaphansi komzuzu"</string>
    <string name="power_usage_time_less_than_one_minute" msgid="8407404329381010144">"Ngaphansi kweminithi"</string>
    <string name="battery_usage_for_total_time" msgid="8402254046930910905">"Inani: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_for_background_time" msgid="9109637210617095188">"Ingemuva: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_time" msgid="3973865893520804115">"Isikhathi sesikrini: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer_empty" msgid="3301144846133808193">"Idatha yokusetshenziswa kwebhethri izotholakala emahoreni ambalwa uma isishajwe ngokugcwele"</string>
    <string name="battery_usage_chart_label_now" msgid="4598282721949430165">"manje"</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">"Ishadi lokusetshenziswa kwebhethri"</string>
    <string name="daily_battery_usage_chart" msgid="4176059567682992686">"Ishadi lokusetshenziswa kwebhethri kwansuku zonke"</string>
    <string name="hourly_battery_usage_chart" msgid="3098314511076561272">"Ishadi lokusetshenziswa kwebhethri ngehora"</string>
    <string name="battery_level_percentage" msgid="1433178290838842146">"Iphesenti leleveli yebhethri ukusuka ku-<xliff:g id="START_PERCENTAGE">%1$s</xliff:g> ukuya ku-<xliff:g id="END_PERCENTAGE">%2$s</xliff:g>"</string>
    <string name="battery_usage_breakdown_title_since_last_full_charge" msgid="435006273323199906">"Ukusetshenziswa kwebhethri kusukela ekushajweni okugcwele kokugcina"</string>
    <string name="battery_usage_breakdown_title_for_slot" msgid="4823179483667671406">"Ukusetshenziswa kwebhethri kwe-<xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="screen_time_category_last_full_charge" msgid="8856908320256057753">"Isikhathi sesikrini kusukela ekushajweni okugcwele kokugcina"</string>
    <string name="screen_time_category_for_slot" msgid="8287722270554654959">"Isikhathi sesikrini se-<xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_spinner_view_by_apps" msgid="8769276544072098082">"Buka ngama-app"</string>
    <string name="battery_usage_spinner_view_by_systems" msgid="7904104223212160541">"Buka ngamasistimu"</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">"Ngenxa yokuhlolwa kwekhwalithi ngaphambi kokuthunyelwa, isibalo somjikelezo singase singabi nguziro ekusetshenzisweni kokuqala"</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Izibalo zenqubo"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Izibalo ze-Geeky mayelana nezinqubo zokuqalisa"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Ukusetshenziswa kwememori"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"<xliff:g id="USEDRAM">%1$s</xliff:g> kokungu-<xliff:g id="TOTALRAM">%2$s</xliff:g> esetshenziswe ngaphezulu kokungu-<xliff:g id="TIMEDURATION">%3$s</xliff:g> kokugcina"</string>
    <string name="process_stats_total_duration_percentage" msgid="4391502694312709148">"<xliff:g id="PERCENT">%1$s</xliff:g> we-RAM esetshenziswe ngaphezulu kwe-<xliff:g id="TIMEDURATION">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="4094034441562453522">"Ingemuva"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"Ingaphambili"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"Kufakwe kunqolobane"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"I-Android OS"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Okwemvelo"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"I-Kernel"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"I-Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Izinqolobane"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"Ukusetshenziswa kwe-RAM"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"Ukusetshenziswa kwe-RAM (okungemuva)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Isikhathi sokuqalisa"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Izinqubo"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Amasevisi"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Ubude besikhathi"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Imininingwane yememori"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 amahora"</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"6 amahora"</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"12 amahora"</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"1 usuku"</string>
    <string name="menu_show_system" msgid="3780310384799907818">"Bonisa isistimu"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Fihla isistimu"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Bonisa amaphesenti"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"Sebenzisa i-Uss"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Uhlobo lwezibalo"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"Ingemuva"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"Ingaphambili"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"Kufakwe kwinqolobane"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Okufakwayo ngezwi; nokukhishwayo"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Okufakwayo ngezwi; nezilungiselelo zokukhishwayo"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Ukusesha ngezwi"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Ikhibhodi ye-Android"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Izungiselelo zokuthayipha ngezwi"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Ukuthayipha ngezwi"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Amasevisi wokuthayipha ngezwi"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"I-hotword ephelele nokusebenzisana"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Inkulumo elula eya embhalweni"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"Le sevisi yokufaka yezwi izokwazi ukwenza ukwengamela okuhlala kuvuliwe kwezwi nokulawula izinhlelo zokusebenza ezinikwe amandla ukulawula izwi engxenyeni yakho. Ivela kuhlelo lokusebenza le <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Nika amandla ukusetshenziswa kwale sevisi?"</string>
    <string name="on_device_recognition_settings" msgid="6503160369314598069">"Amasethingi okubonwa kudivayisi"</string>
    <string name="on_device_recognition_settings_title" msgid="7137599722039096545">"Ukubonwa kudivayisi"</string>
    <string name="on_device_recognition_settings_summary" msgid="3292736423223499348">"Ukubonwa kwengxoxo kudivayisi"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Injini encanyelwayo"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Izilungiselelo zenjini"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Ukulinganisela kwenkulumo nokuzwakala"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Injini"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Amazwi"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Ulimi olukhulunywayo"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Faka amezwi"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Qhubekela kuhlelo lokusebenza le-<xliff:g id="TTS_APP_NAME">%s</xliff:g> ukuze ufake amezwi"</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"Vula uhlelo lokusebenza"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Khansela"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Setha kabusha"</string>
    <string name="tts_play" msgid="2945513377250757221">"Dlala"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"I-VPN"</string>
    <string name="vpn_settings_insecure_single" msgid="9012504179995045195">"Akuphephile"</string>
    <string name="vpn_settings_single_insecure_multiple_total" msgid="6107225844641301139">"I-<xliff:g id="VPN_COUNT">%d</xliff:g> ayiphephile"</string>
    <string name="vpn_settings_multiple_insecure_multiple_total" msgid="1706236062478680488">"I-<xliff:g id="VPN_COUNT">%d</xliff:g> ayiphephile"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Uxhumo lwe-adaptive"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Kunweba impilo yebhethri kuphinde kuthuthukise ukusebenza kwedivayisi ngokuphatha uxhumo lenethiwekhi yakho ngokuzenzakalelayo"</string>
    <string name="adaptive_connectivity_switch_on" msgid="3653067561620745493">"Vuliwe"</string>
    <string name="adaptive_connectivity_switch_off" msgid="5076172560836115265">"Valiwe"</string>
    <string name="adaptive_connectivity_main_switch_title" msgid="261045483524512420">"Sebenzisa uxhumano oluguquguqukayo"</string>
    <string name="credentials_title" msgid="7535942196886123656">" Isitoreji sokuqinisekisa"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Faka isitifiketi"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Sula ukufakazela ubuqiniso"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Susa zonke izitifiketi"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Izifakazeli ezithenjwayo"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Bonisa izitifiketi ze-CA ezithenjwayo"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Ukuqinisekisa komsebenzisi"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Buka uphinde ulungise ukuqinisekisa okugciniwe"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Ithuthukisiwe"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Izifakazo azitholakaleli lo msebenzisi"</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Kufakelwe i-VPN nezinhlelo zokusebenza"</string>
    <string name="credential_for_wifi" msgid="2286560570630763556">"Kufakelwe i-Wi-Fi"</string>
    <string name="credential_for_wifi_in_use" msgid="7276290656840986618">"Kufakelwe i-Wi-Fi (Kuyasetshenziswa)"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Susa konke okuqukethwe?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Isitoreji sokuqinisekisa sisuliwe."</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Ukulonda kokuqinisekia akwazanga ukusulwa."</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Izinhlelo zokusebenza ezinokufinyelela kokusebenza"</string>
    <string name="ca_certificate" msgid="3076484307693855611">"Isitifiketi se-CA"</string>
    <string name="user_certificate" msgid="6897024598058566466">"I-VPN nesitifiketi somsebenzisi sohlelo lokusebenza"</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"Isitifiketi se-Wi-Fi"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Idatha yakho ngeke ibe eyimfihlo"</string>
    <string name="ca_certificate_warning_description" msgid="8409850109551028774">"Izitifiketi ze-CA zisetshenziswa amawebhusayithi, ama-app, kanye nama-VPN ngokubethela. Faka kuphela izitifiketi ze-CA kusukela kuzinhlangano ozithembayo. \n\nUma ufaka isitifiketi se-CA, umnikazi wesitifiketi angase afinyelele kudatha yakho, njengamaphasiwedi nemininingwane yekhadi lesikweletu, kusuka kumawebhusayithi owavakashelayo noma kuma-app owasebenzisayo – ngisho noma idatha yakho ibetheliwe."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Ungafaki"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Faka noma kunjalo"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Isitifiketi asifakiwe"</string>
    <string name="request_manage_credentials_title" msgid="596805634568013413">"Vumela i-"<b>"<xliff:g id="APP_NAME">^1</xliff:g>"</b>" ukuba ifake izitifiketi kule divayisi?"</string>
    <string name="request_manage_credentials_description" msgid="8044839857171509619">"Lezi zitifikethi zizokuqinisekisa ngokwabelana namadivayisi akho we-ID ehlukile ngama-app nama-URL angezansi"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Ungavumeli"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Vumela"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Bonisa okuningi"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"Uhlelo lokusebenza lokuphatha isitifiketi"</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Lutho"</string>
    <string name="certificate_management_app_description" msgid="8507306554200869005">"Izitifikethi zizoqinisekisa uma usebenzisa ama-app nama-URL angezansi"</string>
    <string name="uninstall_certs_credential_management_app" msgid="4945883254446077354">"Khipha izitifikethi"</string>
    <string name="remove_credential_management_app" msgid="6089291496976812786">"Susa uhlelo lokusebenza"</string>
    <string name="remove_credential_management_app_dialog_title" msgid="5713525435104706772">"Susa le app?"</string>
    <string name="remove_credential_management_app_dialog_message" msgid="7739474298063646935">"Le app ngeke iphathe izitifiketi, kodwa izohlala kudivayisi yakho. Noma yiziphi izitifiketi ezifakwe i-app zizokhishwa."</string>
    <string name="number_of_urls" msgid="1128699121050872188">"{count,plural, =1{I-URL engu-#}one{Ama-URL angu-#}other{Ama-URL angu-#}}"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Isignali yokudayela isimo esiphuthumayo"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Hlela ukuziphatha lapho ikholi oluphuthumayo lwenziwa"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Sekela ngokulondoloza"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Isipele ukubuyiselwa"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Idatha yomuntu siqu"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Sekela ngokulondoloza idatha yami"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"Sekela ngokulondoloza idatha yohlelo lokusebenza, amaphasiwedi e-Wi-Fi, nezinye izilungiselelo kwumaseva we-Google"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Sekela ngokulondoloza i-akhawunti"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Phatha i-akhawunti yesipele"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Bandakanya idatha yohlelo lokusebenza"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Ukubuyisela esimweni okuzenzakalelayo"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"Uma ufaka futhi uhlelo lokusebenza, buyisela okuhlelwe ukusebenza kwezipele kanye nemininingo"</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Isevisi yokwenza isipele ayisebenzi"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Ayikho i-akhawunti okwamanje egcina ukusekela ngokulondoloza idatha"</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"Yeka ukulondoloza amaphasiwedi akho e-Wi-Fi, amabhukhimaki, ezinye izilungiselelo, kanye nedatha yezinhlelo zokusebenza, nokususa onke amakhophi kumaseva we-Google?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="2379053988557486162">"Misa ukwenza isipele idatha yedivayisi (njengamaphasiwedi we-Wi-Fi nomlando wekholi) nedatha yohlelo lokusebenza (njengezilungiselelo namafayela alondolozwe izinhlelo zokusebenza), futhi nokusula wonke amakhophi kumaseva werimothi?"</string>
    <string name="fullbackup_data_summary" msgid="971587401251601473">"Yenza isipele ngokuzenzakalela idatha yedivayisi (efana namaphasiwedi we-Wi-Fi nomlando wokushaya) nedatha yohlelo lokusebenza (efana nezilungiselelo namafayela agcinwe yizinhlelo zokusebenza) ngokulawula kude.\n\nUma uvula isipele ngokuzenzakalela, idivayisi nedatha yohlelo lokusebenza ilondolozwa ngesikhathi ezithile ngesilawuli kude. Idatha yohlelo lokusebenza ingaba yinoma iyiphi idatha elondolozwe wuhlelo lokusebenza (kususelwa kuzilungiselelo zonjiniyela), efaka idatha enekhono lokuzwela njengoxhumana nabo, imilayezo, nezithombe."</string>
    <string name="device_admin_settings_title" msgid="31392408594557070">"Izilungiselelo zomlawuli wedivayisi"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"Uhlelo lokusebenza lomlawuli wedivayisi"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Yekisa ukusebenza lolu hlelo lokusebenza lomlawuli wedivayisi"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Khipha uhlelo lokusebenza"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Yekisa futhi ukhiphe"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Ama-app omlawuli wedivayisi"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"Azikho izinhlelo zokusebenza zomlawuli wedivayisi ezitholakalayo"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"Abekho abenzeli bethemba abatholakalayo"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Sebenzisa uhlelo lokusebenza lomlawuli wedivayisi?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Sebenzisa lolu hlelo lokusebenza lomlawuli wedivayisi"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Umlawuli wedivayisi"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Ukusebenzisa lolu hlelo lokusebenza lomlawuli kuzovumela uhlelo lokusebenza <xliff:g id="APP_NAME">%1$s</xliff:g> ukwenza imisebenzi elandelayo:"</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"Le divayisi izophathwa iphinde iqashelwe i-<xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"Lolu hlelo lokusebenza lomlawuli liyasebenza futhi livumela uhlelo lokusebenza <xliff:g id="APP_NAME">%1$s</xliff:g> ukwenza imisebenzi elandelayo:"</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"Sebenzisa isiphathi sephrofayela?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Vumela ukugadwa?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Ngokuqhubeka, umsebenzisi wakho uzophathwa ulawuli wakho ongahle akwazi ukulondoloza idatha ephathelene, ngokwengeziwe kudatha yakho yomuntu siqu.\n\nUmlawuli wakho unamandla okwengamela izilungiselelo, ukufinyelela, izinhlelo zokusebenza nedatha ephathelene nalo msebenzisi, kufaka phakathi umsebenzi wenethiwekhi nolwazi lwakho lwendawo yedivayisi."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"Ezinye izinketho zikhutshazwe umlawuli wakho"</string>
    <string name="admin_more_details" msgid="4928985331640193758">"Funda kabanzi"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Ilogu yesaziso"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Umlando wesaziso"</string>
    <string name="notification_history_today" msgid="6081829638548808795">"Amahora angu-%d wokugcina"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Kusnuziwe"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Okucashiswe kamuva nje"</string>
    <string name="notification_history_count" msgid="885305572972482838">"{count,plural, =1{Isaziso esingu-#}one{Izaziso ezingu-#}other{Izaziso ezingu-#}}"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Ithoni yokukhala yekholi nokudlidliza"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Imininingwane yenethiwekhi"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Ukunika amandla kuvumelanisiwe"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Ukuvumelanisa kukhubaziwe"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Iyavumelanisa manje"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Iphutha lokuvumelanisa."</string>
    <string name="sync_failed" msgid="3806495232114684984">"Ukuvumelanisa kwehlulekile"</string>
    <string name="sync_active" msgid="5787407579281739975">"Ukuvumelanisa kuyasebenza"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Vumelanisa"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"Ukuvumelanisa okwamanje kubhekene nenkinga. Izobuya maduze."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Yengeza  i-akhawunti"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Iphrofayela yomsebenzi ayitholakali okwamanje"</string>
    <string name="work_mode_label" msgid="4687734487641548872">"Ama-app omsebenzi"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Susa iphrofayela yomsebenzi"</string>
    <string name="background_data" msgid="321903213000101158">"Idatha yasemuva"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Izinhlelo zokusebenza zingavumelanisa, zithumele, futhi zithole imininingo nganoma isiphi isikhathi"</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Yekisa ukusebenza kwimininingo yemininingo egciniwe?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"Ukuvimbela idatha yasemuva kwandisa ukuphila kwebhethri futhi kwehlisa ukusebenzisa idatha. Ezinye izinhlelo zokusebenza zingase zisebenzise idatha yasemuva."</string>
    <string name="sync_enabled" msgid="5794103781356455043">"Ukuvumelanisa KUVULIWE"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Ukuvumelanisa KUVALIWE"</string>
    <string name="sync_error" msgid="846923369794727644">"Iphutha lokuvumelanisa"</string>
    <string name="last_synced" msgid="1527008461298110443">"Ukuvumelanisa kokugcina <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Vumelanisa manje..."</string>
    <string name="settings_backup" msgid="5357973563989458049">"Sekela ngokulondoloza izilungiselelo"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Sekela ngokulondoloza izilungiselelo zami"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Vumelanisa manje"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Khansela ukuvumelanisa"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Thepha ukuze uvumelanise manje<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">"Ikhalenda"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Othintana nabo"</string>
    <string name="header_application_sync_settings" msgid="7427706834875419243">"Izilungiselelo zokuvumelanisa uhlelo lokusebenza"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Idatha nokuvumelanisa"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Shintsha iphasiwedi"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Izilungiselelo ze-akhawunti"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Susa i-akhawunti"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Yengeza i-akhawunti"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Khipha i-akhawunti"</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"Lolu shintsho aluvunyelwe umlawuli wakho"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Ayikwazi ukuvumelanisa ngesandla"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"Ukuvumelanisa kwalentwana kuvimbelwe okwamanje. Ukushintsha okukhethwayo kwakho, vula idatha yasemuva nokuvumelanisa okuzenzakalelayo."</string>
    <string name="delete" msgid="8330605554706263775">"Susa"</string>
    <string name="select_all" msgid="7898929601615536401">"Khetha konke"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Ukusebenzisa idatha"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Idatha yeselula kanye ne-Wi‑Fi"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Vumelanisa ngokuzenzakalelayo idatha yakho"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Vumelanisa ngokuzenzakalelayo idatha yomsebenzi"</string>
    <string name="account_settings_menu_auto_sync_private" msgid="2315144351530596228">"Vumelanisa ngokuzenzakalelayo idatha eyimfihlo"</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Shintsha umjikelezo"</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Usuku lwenyanga lokusetha kabusha ukusebenza kwedatha:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"Azikho izinhlelo zokusebenza ezisebenzise idatha phakathi nalesi sikhathi."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Ingaphambili"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Ingemuva"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"kuvinjelwe"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Vala idatha yeselula?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Setha umkhawulo wedatha yeselula"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Setha umkhawulo wedatha ye-4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Setha umkhawulo wedatha ube ye-2G-3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Setha umkhawulo wedatha ye-Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"I-Wi-Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="2951873059375493878">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="952231704205870928">"Iselula"</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">"Iselula"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"Lutho"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Idatha yeselula"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"idatha ye-2G-3G"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"idatha ye-4G"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Iyazulazula"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"Ingaphambili:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"Ingemuva:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"Izilungiselelo zohlelo lokusebenza"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Idatha engemuva"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Nika amandla ukusetshenziswa kwedatha yeselula ngemuva"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Ukuze ubeke umkhawulo wezisetshenziswa zangemuva zalesi sisetshenziswa, qala ulungise umkhawulo wemininingo yeselula."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"Beka isivimbelo kwimininingo yemininingo egciniwe?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"Lesi sici singahle sibangele uhlelo lokusebenza olukhosele kudatha yokwangasemuva ukungasasebenzi uma amanethiwekhi kuphela eselula atholakala.\n\nUngathola ukulawula kokusetshenziswa kwedatha okufanele kuzilungiselelo ezitholakalayo ngaphakathi kohlelo lokusebenza."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="8599940395497268584">"Ukukhawulela idatha engemuva kuyakhonakala kuphela uma usethe umkhawulo wedatha weselula."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"Khanyisa ukuvumelanisa idatha ngokuzenzakalelayo?"</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"Cima ukuvumelanisa idatha ngokuzenzakalela?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"Lokhu kuzokonga ukusetshenziswa kwedatha nebhethri, kepha uzodinga ukuvumelanisa i-akhawunti ngayinye ngokwenza ukuze uqoqe ulwazi lakamuva. Futhi ngeke uthole izaziso uma izibuyekezo zivela."</string>
    <string name="data_usage_cycle_editor_title" msgid="2019035830921480941">"Idethi yokuhlela kabusha umjikelezo wokusebenza"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Idethi yenyanga ngayinye:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Hlela"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Setha isexwayiso sokusebenziseka kwedatha"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Setha umkhawulo wokusetshenziswa kwedatha"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Ilinganisela ukusebenza kwedatha"</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">"isexwayiso"</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">"umkhawulo"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Izinhlelo zokusebenza zisusiwe"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Izinhelo zokusebenza nabasebenzisi abasusiwe"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Ukusebenzisa inethiwekhi"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"Kulinganisiwe"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Igama"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Uhlobo"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Ikheli leseva"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"Isiqaphelisi se-IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"Ukhiye owabelene ngaphambili we-IPSec"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"Isitifiketi somsebenzisi we-IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"Izitifiketi ze-IPSec CA"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"IPSec izitifiketi se-server"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Bonisa okukhethwa kukho okuseqophelweni"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Igama lomsebenzisi"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Iphasiwedi"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Lolondoloza ulwazi lwe-akhawunti"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(ayisetshenziswa)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(ungaqinisekisi iseva)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(itholakale kwi-server)"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"Ulwazi olufakiwe alisekeli i-VPN ehlala ivulekile"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Khansela"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Cashisa"</string>
    <string name="vpn_save" msgid="683868204634860888">"Londoloza"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Xhuma kwi-inthanethi"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Miselela"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"Hlela iphrofayela ye-VPN"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Khohlwa"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Xhuma ku-<xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Nqamula le-VPN"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Nqamula"</string>
    <string name="vpn_version" msgid="6344167191984400976">"Uhlobo"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Khohlwa i-VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Shintshanisa i-VPN ekhona?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Setha i-VPN ehlala ivuliwe?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Uma lesi silungiselelo sivulekile, ngeke ube nokuxhumeka kwe-inthanethi kuze kuxhumeke i-VPN ngempumelelo"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"I-VPN yakho ekhona izoshintshaniswa, futhi ngeke ube nokuxhumeka kwe-inthanethi i-VPN ize ixhumeke ngempumelelo"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Usuvele uxhumeke ku-VPN ehlala ivuliwe. Uma uxhumeka kwehlukile, i-VPN yakho ekhona izoshintshaniswa, futhi imodi yokuhlala ivuliwe izovalwa."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Usuvele uxhumekile ku-VPN. Uma uxhua kwehlukile, i-VPN izoshintshaniswa."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Vula"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"<xliff:g id="VPN_NAME">%1$s</xliff:g> ayikwazi ukuxhuma"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"Lolu hlelo lokusebenza alisekeli i-VPN ehlala ivulekile"</string>
    <string name="vpn_title" msgid="3068868814145870274">"I-VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"Engeza iphrofayela ye-VPN"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Hlela iphrofayela"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Susa iphrofayela"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"I-VPN ehlala ikhanya"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Awekho ama-VPNs angeziwe"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Hlala uxhumekile ku-VPN ngazo zonke izikhathi"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Akusekelwa yilolu hlelo lokusebenza"</string>
    <string name="vpn_always_on_summary_active" msgid="175877594406330387">"Njalo ivuliwe"</string>
    <string name="vpn_insecure_summary" msgid="4450920215186742859">"Akuphephile"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Vimbela uxhumo ngaphandle kwe-VPN"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"Kudingeka uxhumo lwe-VPN?"</string>
    <string name="vpn_insecure_dialog_subtitle" msgid="1857621742868835300">"Akuphephile. Buyekezela ku-IKEv2 VPN"</string>
    <string name="vpn_start_unsupported" msgid="7139925503292269904">"Yehlulekile ukuqalisa i-VPN engasekelwa."</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Khetha iphrofayela ye-VPN ukuhlala uxhumekile. I-traffic yenethiwekhi izovunyelwa kuphela uma ixhunyiwe kule-VPN."</string>
    <string name="vpn_lockdown_none" msgid="455915403560910517">"Akunalutho"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"I-VPN ehlala ikhanya idinga ikheli le-IP kwisiphakeli ne-DNS."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"Alukho uxhumo lenethiwekhi. Sicela uzame futhi emva kwesikhathi."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Kunqanyuliwe kusuka ku-VPN"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Lutho"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Isitifiketi silahlekile. Zama ukuhlela iphrofayela."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"Isistimu"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Umsebenzisi"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Khubaza"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Vumela"</string>
    <string name="trusted_credentials_remove_label" msgid="8296330919329489422">"Khipha"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Themba"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"Vumela isitifiketi sesistimu se-CA?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"Khubaza isitifiketi sesistimu se-CA"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"Susa ngokuphelele isitifiketi se-CA somsebenzidi?"</string>
    <string name="credential_being_used_by" msgid="3682869943025283499">"Kusetshenziswa yi-"</string>
    <string name="credential_contains" msgid="3146519680449595771">"Lokhu okungenayo kuqukethe"</string>
    <string name="one_userkey" msgid="6363426728683951234">"Ukhiye womsebenzisi o-1"</string>
    <string name="one_usercrt" msgid="2097644070227688983">"Isitifiketi somsebenzisi esi-1"</string>
    <string name="one_cacrt" msgid="982242103604501559">"Isitifiketi se-CA esi-1"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"%d CA izitifiketi"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Imininingwane yokuqinisekisa"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Ukuqinisekisa okususiwe: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Akukho ukuqinisekisa okufakiwe"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Umhloli wokupela"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Isihloli sokupeleta somsebenzi"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Faka lapha iphasiwedi yakho yokusekela ngokulondoloza okugcwele"</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Faka lapha iphasiwedi entsha yokusekela ngokulondoloza okugcwele"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Thayipha futhi iphasiwedi yakho yokusekela ngokulondoloza okugcwele"</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Misa iphasiwedi yokusekela ngokulondoloza"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Khansela"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Ukubuyekeza kwesistimu okwengeziwe"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Inethiwekhi kungenzeka iqashiwe"</string>
    <string name="done_button" msgid="6269449526248267">"Kwenziwe"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="1032088078702042090">"{count,plural, =1{Themba noma susa isitifiketi}one{Themba noma susa izitifiketi}other{Themba noma susa izitifiketi}}"</string>
    <string name="ssl_ca_cert_info_message_device_owner" msgid="7528581447864707873">"{numberOfCertificates,plural, =1{U-{orgName} ufake igunya lesitifiketi kudivayisi yakho, okungamvumela ukuqapha umsebenzi wakho wenethiwekhi yedivayisi, kufaka phakathi, ama-imeyili, ama-app, nokuvikela amawebhusayithi.\n\nNgolwazi olungeziwe, xhumana nomlawuli wakho.}one{U-{orgName} ufake amagunya wesitifiketi kudivayisi yakho, okungamvumela ukuthi aqaphe umsebenzi wenethiwekhi yedivayisi yakho, kufaka phakathi ama-imeyili, ama-app, nokuvikela amawebhusayithi.\n\nNgolwazi olungeziwe ngalezi zitifiketi, xhumana nomlawuli wakho.}other{U-{orgName} ufake amagunya wesitifiketi kudivayisi yakho, okungamvumela ukuthi aqaphe umsebenzi wenethiwekhi yedivayisi yakho, kufaka phakathi ama-imeyili, ama-app, nokuvikela amawebhusayithi.\n\nNgolwazi olungeziwe ngalezi zitifiketi, xhumana nomlawuli wakho.}}"</string>
    <string name="ssl_ca_cert_info_message" msgid="3111724430981667845">"{numberOfCertificates,plural, =1{U-{orgName} ufake igunya lesitifiketi sephrofayela yakho yomsebenzi, okungamvumela ukuthi angamele umsebenzi wenethiwekhi yakho yomsebenzi, kufaka phakathi ama-imeyili, ama-app, nokuvikela amawebhusayithi.\n\nNgolwazi olungeziwe, xhumana nomlawuli wakho.}one{U-{orgName} ufake amagunya wesitifiketi wephrofayela yakho yomsebenzi, angamvumela ukuthi aqaphe umsebenzi wenethiwekhi yomsebenzi, ofaka ama-imeyili, ama-app, namawebhusayithi avikelekile.\n\nngolwazi olubanzi ngalezi zitifiketi, xhumana nomlawuli wakho.}other{U-{orgName} ufake amagunya wesitifiketi wephrofayela yakho yomsebenzi, angamvumela ukuthi aqaphe umsebenzi wenethiwekhi yomsebenzi, ofaka ama-imeyili, ama-app, namawebhusayithi avikelekile.\n\nngolwazi olubanzi ngalezi zitifiketi, xhumana nomlawuli wakho.}}"</string>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"Inkampani yangaphandle iyakwazi ukugada umsebenzi wakho wenethiwekhi, ofaka ama-imeyili, izinhlelo zokusebenza, namawebhusayithi aphephile.\n\nUkuqinisekisa okuthenjiwe okufakwe kudivayisi yakho kwenza lokhu kukhoneke."</string>
    <string name="ssl_ca_cert_settings_button" msgid="2044927302268394991">"{count,plural, =1{Hlola isitifiketi}one{Hlola izitifiketi}other{Hlola izitifiketi}}"</string>
    <string name="user_settings_title" msgid="6550866465409807877">"Abasebenzisi abaningi"</string>
    <string name="user_list_title" msgid="1387379079186123404">"Abasebenzisi namaphrofayela"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Engeza umsebenzisi noma iphrofayela"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Iphrofayela evinjelwe"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Akukho ukusetha"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Akusethiwe - Iphrofayela evinjelwe"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Ayisethiwe - Iphrofayela yomsebenzi"</string>
    <string name="user_admin" msgid="4024553191395768119">"Mqondisi"</string>
    <string name="user_you" msgid="3070562015202859996">"Wena (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="3328539978480663740">"Awukazi ukwengeza abanye abasebenzisi. Susa umsebenzisi ukuze wengeze omusha."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Amaphrofayela akhawulelwe awakwazi ukungeza ama-akhawunti"</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Susa i-<xliff:g id="USER_NAME">%1$s</xliff:g> kule divayisi"</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Khiya izilungiselelo zesikrini"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Engeza abasebenzisi kusuka esikrinini sokukhiya"</string>
    <string name="switch_to_dock_user_when_docked" msgid="2324395443311905635">"Gukukela kumsebenzisi ongumphathi lapho kudokhiwe"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Zisuse wena?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Susa lo msebenzisi?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Susa le phrofayela?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Susa iphrofayela yomsebenzi?"</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Zonke izinhlelo zokusebenza nedatha kuzosuswa."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"Zonke izinhlelo zokusebenza nedatha kule phrofayela kuzosulwa unaphakade uma uqhubeka."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Wonke ama-app nedatha kuzosuswa."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Ingeza umsebenzisi omusha…"</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Susa umsebenzisi"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Susa"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Wonke ama-app nedatha kulesi sikhathi azosuswa."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Susa"</string>
    <string name="guest_category_title" msgid="5562663588315329152">"Isihambeli (Wena)"</string>
    <string name="user_category_title" msgid="4368580529662699083">"Abasebenzisi"</string>
    <string name="other_user_category_title" msgid="7089976887307643217">"Abanye abasebenzisi"</string>
    <string name="remove_guest_on_exit" msgid="8202972371459611066">"Sula umsebenzi wesihambeli"</string>
    <string name="remove_guest_on_exit_summary" msgid="3969962695703280353">"Sula wonke ama-app wesihambeli nedatha lapho uphuma kwimodi yesivakashi"</string>
    <string name="remove_guest_on_exit_dialog_title" msgid="2310442892536079416">"Sula umsebenzi wesihambeli?"</string>
    <string name="remove_guest_on_exit_dialog_message" msgid="8112409834021851883">"Ama-app nedatha okusuka kulesi sikhathi sesihambeli kuzosulwa manje, wonke umsebenzi wesihambeli wesikhathi esizayo uzosulwa njalo lapho uphuma kwimodi yesivakashi."</string>
    <string name="remove_guest_on_exit_keywords" msgid="4961310523576166193">"sula, isivakashi, umsebenzi, susa, idatha, isivakashi, sula"</string>
    <string name="enable_guest_calling" msgid="4620657197834392094">"Vumela isihambeli ukuthi senze amakholi wefoni"</string>
    <string name="enable_guest_calling_summary" msgid="4748224917641204782">"Umlando wekholi uzokwabiwa nomsebenzisi wesihambeli"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Vula amakholi wefoni ne-SMS"</string>
    <string name="user_grant_admin" msgid="5942118263054572074">"Yenza lo msebenzisi abe umphathi"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Susa umsebenzisi"</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Vula amakholi wefoni ne-SMS?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"Umlando wekholi ne-SMS uzokwabiwa nalo msebenzisi."</string>
    <string name="user_revoke_admin_confirm_title" msgid="3057842401861731863">"Susa amalungelo okuphatha?"</string>
    <string name="user_revoke_admin_confirm_message" msgid="9207187319308572958">"Uma ususa amalungelo okuphatha alo msebenzisi, wena noma omunye umlawuli ningawabuyisela kamuva."</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Ulwazi lwesimo esiphuthumayo"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Ulwazi noxhumana nabo baka-<xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="open_app_button" msgid="5025229765547191710">"Vula i-<xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Vumela izinhlelo zokusebenza nokuqukethwe"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Izinhlelo zokusebenza ezinomkhawulo"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Nweba izilungiselelo zohlelo lokusebenza"</string>
    <string name="user_choose_copy_apps_to_another_user" msgid="5914037067347012870">"Khetha ama-app ozowafaka"</string>
    <string name="user_copy_apps_menu_title" msgid="5354300105759670300">"Faka ama-app atholakalayo"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Ukukhokha ngaphandle kokuthinta"</string>
    <string name="nfc_default_payment_settings_title" msgid="2150504446774382261">"I-app yenkokhelo ezenzakalelayo"</string>
    <string name="nfc_default_payment_footer" msgid="978535088340021360">"Ukuze wenze inkokhelo usebenzisa i-app yokukhokha, bamba ingemuva ledivayisi yakho kutheminali yenkokhelo"</string>
    <string name="nfc_more_details" msgid="1700713533074275233">"Funda kabanzi"</string>
    <string name="nfc_default_payment_workapp_confirmation_title" msgid="746921251872504687">"Setha i-app yomsebenzi njenge-app yenkokhelo yokuzenzakalelayo?"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_title" msgid="1533022606333010329">"Ukuze wenze inkokhelo usebenzisa i-app yomsebenzi:"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_1" msgid="2917430119080702912">"iphrofayela yomsebenzi kufanele ivulwe."</string>
    <string name="nfc_default_payment_workapp_confirmation_message_2" msgid="8161184137833245628">"kuzodingeka ufake i-PIN yakho yomsebenzi, iphethini, noma iphasiwedi uma unayo."</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Indlela esebenza ngayo"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Khokha ngefoni yakho ezitolo"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"Okuzenzakalelayo kwenkokhelo"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Ayisethiwe"</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">"Sebenzisa i-app yokukhokha yokuzenzakalalelayo"</string>
    <string name="nfc_payment_use_default_dialog" msgid="8556328090777785383">"Sebenzisa i-app yokukhokha yokuzenzakalalelayo"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Njalo"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"Ngaphandle kokuthi olunye uhlelo lokusebenza lokukhokha luvuliwe"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"Kutheminali yangaphandle kokuthinta, khokha nge-:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Ukukhokha kutheminali"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Setha uhlelo lokusebenza lokhukhokha. Bese vele ubambe ingemuva lefoni yakho kuya kunoma iyiphi itheminali enophawu elingenabo oxhumana nabo."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"Ngiyitholile"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Okuningi…"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Setha uhlelo lokusebenza olukhokhelwayo oluzenzakalelayo"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Buyekeza uhlelo lokusebenza olukhokhelwayo oluzenzakalelayo"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"Kutheminali yangaphandle kokuthinta, khokha nge-<xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"Kutheminali yangaphandle kokuthinta, khokha nge-<xliff:g id="APP_0">%1$s</xliff:g>.\n\nLokhu kuthatha isikhundla se-<xliff:g id="APP_1">%2$s</xliff:g> njengohlelo lwakho lokusebenza olukhokhelwayo oluzenzakalelayo."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Hlela okuzenzakalelayo"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Buyekeza"</string>
    <string name="nfc_work_text" msgid="2496515165821504077">"Umsebenzi"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Izinciphiso"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Susa izinciphiso"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Shintsha i-PIN"</string>
    <string name="help_label" msgid="2896538416436125883">"Usizo nempendulo"</string>
    <string name="user_account_title" msgid="6389636876210834864">"I-akhawunti yokuqukethwe"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"I-ID yesithombe"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Izinsongo ezinkulu"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Thola izexwayiso ngezisongo ezinkulu zempilo nendawo"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Izinsongo ezicindezelayo"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Thola izexwayiso ngezinsingo ezicindezelayo zempilo nendawo"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"Izexwayiso ze-AMBER"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Thola izihloko zezindaba mayelana nokulahleka kwezingane"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Phinda"</string>
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Izexwayiso zesimo esiphuthumayo"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Imisebenzi yenethiwekhi"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Amagama wephoyinti lokufinyelela"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"I-VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Ukushaya okuthuthukile"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"Ukushaya kwe-4G"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1067066329756036427">"Sebenzisa amasevisi we-LTE ukuthuthukisa amakholi akho ezwi (kuyanconywa)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="2575004054914178405">"Sebenzisa amasevisi we-4G ukuthuthukisa amakholi akho ezwi (kuyanconywa)"</string>
    <string name="nr_advanced_calling_title" msgid="6106286679535355939">"I-Vo5G"</string>
    <string name="nr_advanced_calling_summary" msgid="6926192539172030330">"Sebenzisa i-5G mayelana namakholi wezwi"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Thumela abathintwayo kunkampani yenethiwekhi"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Thumela izinombolo zefoni zabathintwayo bakho ukuze uhlinzeke ngezici ezithuthukile"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Thumela abathintwayo ku-<xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"Thumela abathintwayo kunkampani yakho yenethiwekhi?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Izinombolo zefoni zabathintwayo bakho zizothunyelwa ngezikhathi ezithile ku-<xliff:g id="CARRIER">%1$s</xliff:g>.<xliff:g id="EMPTY_LINE">

</xliff:g>Lolu lwazi lukhoma ukuthi abathintwayo bakho bangazisebenzisa yini izici ezithile, njengekholi yevidiyo noma ezinye izici zemilayezo."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"Izinombolo zefoni zabathintwayo bakho zizothunyelwa ngezikhathi ezithile kunkampani yakho yenethiwekhi.<xliff:g id="EMPTY_LINE">

</xliff:g>Lolu lwazi lukhoma ukuthi abathintwayo bakho bangazisebenzisa yini izici ezithile, njengekholi yevidiyo noma ezinye izici zemilayezo."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Uhlobo lwenethiwekhi oluncamelayo"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"I-LTE (inconyiwe)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"Imilayezo ye-MMS"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Thumela uphinde wamukele uma idatha yeselula ivaliwe"</string>
    <string name="auto_data_switch_title" msgid="5862200603753603464">"Shintsha idatha yeselula ngokuzenzakalela"</string>
    <string name="auto_data_switch_summary" msgid="1934340931995429057">"Sebenzisa le nethiwekhi uma inokutholakala okungcono"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"I-SIM yomsebenzi"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Ukufinyelela kwezinhlelo zokusebenza nokuqukethwe"</string>
    <string name="user_rename" msgid="8735940847878484249">"QAMBA KABUSHA"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Misa imikhawulo yohlelo"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Ilawulwa yi-<xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Lolu hlelo lokusebenza lingafinyelela kuma-akhawunti wakho"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"Lolu hlelo lokusebenza lungafinyelela kuma-akhawunti wakho. Kulawulwa yi-<xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="2630656989926554685">"I-Wi‑Fi neselula"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Vumela ukushintsha kwezilungiselelo ze-Wi-Fi nezeselula"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Vumela ukushintshwa kokubhanqwa kwe-Bluetooth nezilungiselelo"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Indawo"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Vumela izinhlelo zokusebenza ukuthi zisebenzise ulwazi lendawo yakho"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Phindela emuva"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Okulandelayo"</string>
    <string name="wizard_back_adoptable" msgid="1447814356855134183">"Fometha ngenye indlela"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_settings_title" msgid="2254609719033946272">"Ama-SIM"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Idatha yeselula ayitholakali"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Thepha ukuze ukhethe i-SIM yedatha"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Njalo sebenzisa lokhu kumakholi"</string>
    <string name="select_sim_for_data" msgid="2642305487659432499">"Khetha i-SIM yedatha yeselula"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Khetha i-SIM ye-SMS"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Ishintsha i-SIM yedatha, lokhu kungathatha kufikela kuminithi…"</string>
    <string name="select_specific_sim_for_data_title" msgid="5851980301321577985">"Sebenzisa i-<xliff:g id="NEW_SIM">%1$s</xliff:g> yedatha yeselula?"</string>
    <string name="select_specific_sim_for_data_msg" msgid="7401698123430573637">"Uma ushintshela ku-<xliff:g id="NEW_SIM">%1$s</xliff:g>, i-<xliff:g id="OLD_SIM">%2$s</xliff:g> ngeke isasetshenziselwa idatha yeselula."</string>
    <string name="select_specific_sim_for_data_button" msgid="6571935548920603512">"Sebenzisa i-<xliff:g id="NEW_SIM">%1$s</xliff:g>"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Shaya nge"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Faka igama le-SIM"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"Isikhala se-SIM %1$d"</string>
    <string name="color_orange" msgid="216547825489739010">"Okuwolintshi"</string>
    <string name="color_purple" msgid="6603701972079904843">"Phephuli"</string>
    <string name="sim_status_title" msgid="6188770698037109774">"Isimo se-SIM"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"Isimo se-SIM (imbobo ye-sim %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">"Ama-SIM akho ashintshile"</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Thepha ukuze usethe"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Buza njalo"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Ukukhetha kuyadingeka"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"Ukhetho lwe-SIM"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Izilungiselelo"</string>
    <string name="network_dashboard_title" msgid="788543070557731240">"Inethiwekhi ne-inthanethi"</string>
    <string name="network_dashboard_summary_mobile" msgid="7750924671970583670">"Okweselula, i-Wi‑Fi, i-hotspot"</string>
    <string name="network_dashboard_summary_no_mobile" msgid="4022575916334910790">"I-Wi‑Fi i-hotspot"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Amadivayisi axhunyiwe"</string>
    <string name="connected_devices_dashboard_default_summary" msgid="7211769956193710397">"I-Bluetooth, ukumatanisa"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"I-Bluetooth, imodi yokushayela, i-NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"I-Bluetooth, imodi yokushayela"</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="7155882619333726331">"I-Bluetooth, i-NFC"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="1175254057213044560">"I-Bluetooth"</string>
    <string name="connected_devices_dashboard_android_auto_summary" msgid="8179090809275818804">"I-Bluetooth, Android Auto, imodi yokushayele, i-NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"I-Bluetooth, Android Auto, imodi yokushayela"</string>
    <string name="connected_devices_dashboard_android_auto_no_driving_mode_summary" msgid="6426996842202276640">"I-Bluetooth, Android Auto, i-NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_no_driving_mode" msgid="1672426693308438634">"I-Bluetooth, Android Auto"</string>
    <string name="nfc_and_payment_settings_payment_off_nfc_off_summary" msgid="7132040463607801625">"Akutholakali ngoba i-NFC ivaliwe"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Ukuze usebenzise, qala ufake uhlelo lokusebenza lwenkokhelo"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Izinhlelo zokusebenza zakamuva, izinhlelo zokusebenza ezizenzakalelayo"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Ukufinyelela kwesaziso akutholakaleli izinhelo zokusebenza kuphrofayela yomsebenzi."</string>
    <string name="account_dashboard_title" msgid="8228773251948253914">"Amaphasiwedi nama-akhawunti"</string>
    <string name="account_dashboard_default_summary" msgid="7976899924144356939">"Iziphakamiso zokungena ngemvume amp;nokugcwalisa okuzenzakalelayo"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Ama-app azenzekelayo"</string>
    <string name="cloned_apps_dashboard_title" msgid="5542076801222950921">"Ama-App Ahlanganisiwe"</string>
    <string name="desc_cloned_apps_intro_text" msgid="1369621522882622476">"Sungula isenzakalo sesibili se-app ukuze ukwazi ukusebenzisa ama-akhawunti amabili ngesikhathi esisodwa."</string>
    <string name="desc_cloneable_app_list_text" msgid="3354586725814708688">"Ama-app angahlanganiswa."</string>
    <string name="cloned_apps_summary" msgid="8805362440770795709">"I-<xliff:g id="CLONED_APPS_COUNT">%1$s</xliff:g> ikhiqiziwe, I-<xliff:g id="ALLOWED_APPS_COUNT">%2$d</xliff:g> iyatholakala ukuze ikhiqizwe"</string>
    <string name="delete_all_app_clones" msgid="3489053361980624999">"Susa wonke ama-clone e-app"</string>
    <string name="delete_all_app_clones_failure" msgid="6821033414547132335">"Sula wonke ama-clone e-App kuhlulekile"</string>
    <string name="cloned_app_creation_summary" msgid="4642627294993918502">"Iyasungula…"</string>
    <string name="cloned_app_created_summary" msgid="7277912971544890710">"Kwenziwe i-clone"</string>
    <string name="cloned_app_creation_toast_summary" msgid="3854494347144867870">"Isungula i-clone ye-<xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="cloned_app_created_toast_summary" msgid="755225403495544163">"Isungulwe i-clone ye-<xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Izilimi, ukuthinta, isikhathi, isipele"</string>
    <string name="languages_setting_summary" msgid="2650807397396180351">"Uhlelo lwezilimi, izilimi ze-app, okukhethwayo esifundeni, inkulumo"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"i-wifi, i-wi-fi, uxhumo lwenethiwekhi, i-inthanethi, i-wireless, idatha, i-wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"Isaziso se-Wi-Fi, isaziso se-wifi"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"ukusetshenziswa kwedatha"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Sebenzisa ifomethi ye-24 amahora"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Vula nge-"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Izinhlelo zokusebenza"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"izoni yendawo"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Inhloko yeshadi, isistimu, isexwayiso, iwindi, ingxoxo, isibonisi, ngaphezu kwezinye izinhlelo zokusebenza, ukulingana"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"I-flashlight, isibani, ithoshi"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"I-wifi, i-wi-fi, guqula, lawula"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"iselula, iselula, inkampani yenethiwekhi yeselula, okungenantambo, idatha, i-4g, i-3g, i-2g, i-lte"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"i-wifi, i-wi-fi, ikholi, ukushaya"</string>
    <string name="keywords_display" msgid="874738809280751745">"isikrini, isikrini esithintwayo"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"fiphaza isikrini, isikrini esithintwayo, ibhethri, kuyakhanya"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"fiphaza isikrini, ubusuku, i-tint, ebusuku, ukukhanya, umbala wesikrini, umbala wesikrini, umbala, umbala"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"ingemuva, yenza kube ngokwakho, enza ngendlela oyifisayo isibonisi"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"usayizi wombhalo"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"iphrojekthi, sakaza, ukufaniselana kwesikrini, ukwabelana kwesikrini, ukufaniselana, ukwabelana kwesikrini, ukusakaza kwesikrini"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"isikhala, idiski, i-hard drive, ukusetshenziswa kwedivayisi"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"ukusetshenziswa kwamanje, shaja"</string>
    <string name="keywords_battery_usage" msgid="1763573071014260220">"buka ukusetshenziswa kwebhethri, ukusetshenziswa kwebhethri, ukusetshenziswa kwamandla"</string>
    <string name="keywords_battery_saver" msgid="6289682844453234359">"isilondolozi sebhethri, isilondolozi samandla, isilondolozi"</string>
    <string name="keywords_battery_adaptive_preferences" msgid="1774870663426502938">"okuncanyelwayo okuvumelana nezimo, i-adaptive battery"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"isipelingi, isichazamazwi, hlola ukupeletwa, lungisa ngokuzenzakalela"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"isiboni, okokufaka, inkulumo, khuluma, ulimi, i-hands-free, okungathintwa ngezandla, ukubonwa, okuhlaselayo, igama, umsindo, umlando, ama-earphone e-bluetooth"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"linganisela, ulimi, okuzenzakalelayo, khuluma, ukukhuluma, i-tts, ukufinyeleleka, isifundi sesikrini, ukungaboni"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"iwashi, okwezempi"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"setha kabusha, buyisela, ifekthri"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"sula, susa, buyisa, sula, susa, setha kabusha"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"iphrinta"</string>
    <string name="keywords_sounds" msgid="187191900698371911">"ibhiphu yesipikha, isipikha, ivolumu, thulisa, ukuthula, umsindo, umculo, i-haptic, isidlidlizi, dlidliza"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"ungaphazamisi ukungaphazamisi, phazamisa, ukuphazamisa, ikhefu"</string>
    <string name="keywords_app" msgid="7983814237980258061">"I-RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"eduze, indawo, umlando, ukubik, i-GPS"</string>
    <string name="keywords_accounts" msgid="3013897982630845506">"i-akhawunti, faka i-akhawunti, iphrofayela yomsebenzi, faka i-akhawunti, susa, sula"</string>
    <string name="keywords_users" msgid="3497517660077620843">"umkhawulo, khawulela, okukhawulelwe"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"ukulungiswa kombhalo, ukulunga, umsindo, ukudlidliza, okuzenzakalelayo, ulimi, ukuthinta, phakamisa, isiphakamiso, itimu, okuhlaselayo, igama, uhlobo, i-emoji, okwamazwe ngamazwe"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"setha kabusha, okuncamelayo, okuzenzakalelayo"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"izinhlelo zokusebenza, landa, izinhlelo zokusebenza, isistimu"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"izinhlelo zokusebenza, izimvume, ukuvikela"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"izinhlelo zokusebenza, okuzenzakalelayo"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"ziba ukulungiselelwa, idosi, ukulinda kohlelo lokusebenza"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"ukudlidlizela, i-RGB, i-sRGB, umbala, okwemvelo, okujwayelekile"</string>
    <string name="keywords_screen_resolution" msgid="6652125115386722875">"FHD, QHD, ukucaca, 1080p, 1440p"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"ithempelesha yombala ngu-D65, D73, okumhlophe, okuliphuzi, okuluhlaza okwesibhakabhaka, okufudumele, okupholile"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"slayida ukuze uvule, iphasiwedi, iphethini, iphinikhodi"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"ukuphina isikrini"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"ukuphonselwa inselelo komsebenzi, umsebenzi, iphrofayela"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"iphrofayela yomsebenzi, iphrofayela ephethwe, ukuhlanganisa, ukuhlanganisa, umsebenzi, iphrofayela"</string>
    <string name="keywords_fold_lock_behavior" msgid="6278990772113341581">"vuka, lala, ungakhiyi, hlala ungakhiyile ekugoqweni, ukugoqa, ukuvala, ukugoqa, ukuvala, ukuvala isikrini"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"ukuthinta"</string>
    <string name="keywords_wallet" msgid="3757421969956996972">"i-wallet"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"khokha, thepha, i-payments"</string>
    <string name="keywords_backup" msgid="707735920706667685">"isipele, yenza isipele"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"ukuvula, ngobuso, gunyaza, ngena ngemvume"</string>
    <string name="keywords_biometric_unlock" msgid="8569545388717753692">"ukuvula, ngobuso, ukufakazela, ukungena ngemvume, isigxivizo somunwe, i-biometrics"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, min, inguqulo ye-prl, imei sv"</string>
    <string name="keywords_sim_status" msgid="4221401945956122228">"inethiwekhi, isimo senethiwekhi yeselula, isimo sesevisi, amandla esignali, uhlobo lwenethiwekhi yeselula, ukuzula,"</string>
    <string name="keywords_sim_status_esim" msgid="3338719238556853609">"inethiwekhi, isimo senethiwekhi yeselula, isimo sesevisi, amandla esiginali, uhlobo lwenethiwekhi yeselula, ukuzula, i-eid"</string>
    <string name="keywords_sim_status_iccid" msgid="4775398796251969759">"inethiwekhi, isimo senethiwekhi yeselula, isimo sesevisi, amandla esignali, uhlobo lwenethiwekhi yeselula, ukuzula, i-iccid"</string>
    <string name="keywords_sim_status_iccid_esim" msgid="4634015619840979184">"inethiwekhi, isimo senethiwekhi yeselula, isimo sesevisi, amandla esiginali, uhlobo lwenethiwekhi yeselula, ukuzula, i-iccid, i-eid"</string>
    <string name="keywords_esim_eid" msgid="8128175058237372457">"i-eid"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"inombolo yomkhiqizo, inguqulo yehadiwe"</string>
    <string name="keywords_battery_info" msgid="3319796850366687033">"ulwazi lwebhethri, ilanga lokukhiqiza, ukubalwa komjikelezo, ukusebenzisa kokuqala"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"ileveli yepeshi yokuvikelwa kwe-android, inguqulo ye-baseband, inguqulo ye-kernel"</string>
    <string name="keywords_dark_ui_mode" msgid="6373999418195344014">"itimu, ukukhanya, imodi emnyama, ukuzelwa kokukhanyayo, i-photophobia, yenza kube mnyama, mnyama, imodi emnyama, i-migraine"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"itimu emnyama"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"isiphazamisi"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Isibonisi se-Ambient, isibonisi sesikrini sokukhiya"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"isaziso sokukhiya isikrini, izaziso"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"ubuso"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"izigxivizo zeminwe, engeza izigxivizo zeminwe"</string>
    <string name="keywords_biometric_settings" msgid="2173605297939326549">"ubuso, isigxivizo somunwe, engeza isigxivizo somunwe"</string>
    <string name="keywords_active_unlock_settings" msgid="4511320720304388889">"vula iwashi, engeza ukuvula iwashi"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"fiphalisa isikrini, isikrini sokuthinta, ibhethri, ukukhanya okuhlakaniphile, ukukhanya okuguqukayo, ukukhanya okuzenzakalelayo"</string>
    <string name="keywords_display_adaptive_sleep" msgid="4905300860114643966">"smathi, fiphalisa isikrini, lala, ibhethri, ukuphelelwa isikhathi, ukunaka, isiboniso, isikrini, ukungasebenzi"</string>
    <string name="keywords_auto_rotate" msgid="7288697525101837071">"ikhamera, smathi, ukuphenduka okuzenzakalelayo, ukuphenduka okuzenzakalelayo, zungezisa, phenya, ukuzungezisa, ukuma ngobude, ukwakheka kwezwe, umumo, okuqondile, okuvundlile"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"thuthukisa, i-android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"i-dnd, ishejuli, izaziso, vimbela, thulisa, ukudlidliza, ukulala, ukusebenza, ukugxila, umsindo, thulisa, nsukuzonke, bonke ubusuko, umculo"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"isikrini, isikhathi sokukhiya, ukuphela kwesikhathi, ukukhiya isikrini"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"imemori, inqolobane, idatha, susa, sula, khulula, isikhala"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"xhuma, idivayisi, ama-headphones, ama-headset, isipika, i-wireless, ipheya, ama-earbuds, umculo, idatha"</string>
    <string name="keywords_wallpaper" msgid="7332890404629446192">"ingemuva, itimu, igeidi, enza ngendlela oyifisayo, yenza kube ngokwakho"</string>
    <string name="keywords_styles" msgid="3367789885254807447">"isithonjana, iphimbo, umbala, isikrini sasekhaya, isikrini sokukhiya, isinqamuleli, usayizi wewashi"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"okuzenzakalelayo, umsizi"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"okuzenzakalelayo kwenkokhelo"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"isaziso esingenayo"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"i-usb tether, i-bluetooth tether, i-wifi hotspot"</string>
    <string name="keywords_accessibility_vibration_primary_switch" msgid="730692154347231253">"ama-haptic, dlidliza, ukudlidliza"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"ama-haptics, ukudlidliza, isikrini, ukuzwela"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"ama-haptics, ukudlidliza, ifoni, ikholi, ukuzwela, ukukhala"</string>
    <string name="keywords_ramping_ringer_vibration" msgid="3678966746742257366">"ama-haptics, ukudlidliza, ifoni, ikholi, ukukhalisa, kancane"</string>
    <string name="keywords_notification_vibration" msgid="2620799301276142183">"i-haptics, ukudlidliza, ukuzwela, isaziso"</string>
    <string name="keywords_alarm_vibration" msgid="4833220371621521817">"i-haptics, ukudlidliza, ukuzwela, i-alamu"</string>
    <string name="keywords_media_vibration" msgid="723896490102792327">"i-haptics, ukudlidliza, ukuzwela, imidiya"</string>
    <string name="keywords_vibration" msgid="670455132028025952">"ama-haptic, dlidliza, ukudlidliza"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"isilondolozi sebhethri, okunamathelayo, ukuqhubeka, ukulondolozwa kwamandla, ibhethri"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"umzila, ishejuli, isilondolozi sebhethri, isilondolozi samandla, ibhethri, ukuzenzakalela, iphesenti"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"i-volte, ukushaya okuthuthukile, ukushaya kwe-4g"</string>
    <string name="keywords_nr_advanced_calling" msgid="4157823099610141014">"I-vo5g, vonr, ukushaya okuthuthukile, ukushaya kwe-5g"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"engeza ulimi, engeza ulimi"</string>
    <string name="keywords_font_size" msgid="1643198841815006447">"usayizi wombhalo, ukuphrinta okukhulu, ifonti enkulu, umbhalo omkhulu, umbono ophansi, yenza umbhalo ube mkhulu, ukukhulisa ifonti, ukukhulisa ifonti"</string>
    <string name="keywords_always_show_time_info" msgid="1066752498285497595">"isibonisi esihlala sikhanya se-ambient, i-AOD"</string>
    <string name="keywords_change_nfc_tag_apps_state" msgid="9032287964590554366">"i-nfc, umaka, isifundi"</string>
    <string name="keywords_keyboard_vibration" msgid="6485149510591654697">"ikhibhodi, ama-haptic, Ukudlidliza,"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Ivolomu, ukudlidliza, ungaphazamisi"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Ivolumu yabezindaba"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Ivolumu yokusakaza"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Ivolumi yocingo"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Ivolumu ye-alamu"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Ivolumu yokukhala neyesaziso"</string>
    <string name="separate_ring_volume_option_title" msgid="2212910223857375951">"Ivolumu yokukhalisa"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Ivolumu yesaziso"</string>
    <string name="ringer_content_description_silent_mode" msgid="1442257660889685934">"Isikhali sithulile"</string>
    <string name="ringer_content_description_vibrate_mode" msgid="5946432791951870480">"Ukudlidliza kwesikhali"</string>
    <string name="notification_volume_content_description_vibrate_mode" msgid="6097212000507408288">"Ivolumu yezaziso ithulisiwe, izaziso zizodlidliza"</string>
    <string name="volume_content_description_silent_mode" msgid="377680514551405754">"<xliff:g id="VOLUME_TYPE">%1$s</xliff:g> kuthulisiwe"</string>
    <string name="notification_volume_disabled_summary" msgid="8679988555852056079">"Ayitholakali ngoba ukukhala kuthulisiwe"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Iringithoni yefoni"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Umsindo wesaziso ozenzakalelayo"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Uhlelo lokusebenza lunikezele ngomsindo"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Umsindo wesaziso ozenzakalelayo"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Umsindo we-alamu ozenzakalelayo"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Mayidlidlize kuqala bese ikhala kancane"</string>
    <string name="spatial_audio_title" msgid="1775370104206884711">"Umsindo Wokulalelwayo"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Amathoni wephedi yokudayela"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Umsindo wokukhiya isikrini"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Imisindo yokushaja nokudlidliz"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Imisindo yokudokha"</string>
    <string name="touch_sounds_title" msgid="826964355109667449">"Imisindo yokuthepha nokuchofoza"</string>
    <string name="vibrate_icon_title" msgid="1281100105045362530">"Bonisa njalo isithonjana lapho usebenzisa imodi yokudlidliza"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Isipikha sedokhu sidlala"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Wonke umsindo"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Umsindo wemidiya kuphela"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Ukuthula"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Amathoni"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Ukudlidlizela"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Amandla kumisindo"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Amagama-ncazo abukhoma"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Yenza amagama-ngcazo ngokuzenzakalela emidiya"</string>
    <string name="spatial_audio_wired_headphones" msgid="2237355789145828648">"Ama-headphone entambo"</string>
    <string name="spatial_audio_text" msgid="8201387855375146000">"Umsindo ovela kumidiya ehambisanayo uba ogxile kakhulu"</string>
    <string name="spatial_summary_off" msgid="8272678804629774378">"Valiwe"</string>
    <string name="spatial_summary_on_one" msgid="6239933399496282994">"Vuliwe / <xliff:g id="OUTPUT_DEVICE">%1$s</xliff:g>"</string>
    <string name="spatial_summary_on_two" msgid="4526919818832483883">"Kuvuliwe / <xliff:g id="OUTPUT_DEVICE_0">%1$s</xliff:g> futhi ne-<xliff:g id="OUTPUT_DEVICE_1">%2$s</xliff:g>"</string>
    <string name="spatial_audio_footer_title" msgid="8775010547623606088">"Ungakwazi nokuvula i-Spatial Audio kumadivayisi e-Bluetooth."</string>
    <string name="spatial_audio_footer_learn_more_text" msgid="3826811708094366301">"Amasethingi wamadivayisi axhunyiwe"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Lutho}=1{ishejuli esethiwe e-1}one{amashejuli asethiwe angu-#}other{amashejuli asethiwe angu-#}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Ungaphazamisi"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Yaziswa kuphela abantu ababalulekile nezinhlelo zokusebenza"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Khawulela ukuphazamisa"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Vula ukungaphazamisi"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Ama-alamu nemisindo yemidiya kungaphazamisa"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Amashejuli"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Susa amashejuli"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Susa"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Hlela"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Amashejuli"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Ishejuli"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Ishejuli"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Thulisa ifoni ngezinye izikhathi"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Setha imithetho yokuthi ungaphazamisi"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Ishejuli"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Sebenzisa ishejuli"</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">"Vumela iziphazamiso ezenza umsindo"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Vimbela ukuphazamiseka okubonakalayo"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Vumela amasignali okubuka"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Bonisa izinketho zezaziso ezifihliwe"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Uma Ukungaphazamisi kuvuliwe"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Awukho umsindo kusukela kuzaziso"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Uzobona izaziso kusikrini sakho"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"Uma kufika izaziso, ifoni yakho ngeke yenze umsindo noma idlidlize."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Akukho okubonakalayo noma umsindo kusukela kuzaziso"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Ngeke ubone noma uzwe izaziso"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="3761837271201073330">"Ifoni yakho ngeke iboniswe, idlidlizele noma yenze umsindo wezaziso ezintsha noma ezikhona. Khumbula, izaziso ezibalulekile zomsebenzi wefoni nesimo sisazovela.\n\nUma uvala ukungaphazamisi, thola izaziso eziphuthelwe ngokuswayiphela phansi kusukela ngaphezulu kwesikrini sakho."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="5469078057954463796">"Ngokwezifiso"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Nika amandla isilungiselelo sangokwezifiso"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Susa isilungiselelo sangokwezifiso"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Awukho umsindo kusukela kuzaziso"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Kufihlwe kancane"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Akukho okubonakalayo noma umsindo kusukela kuzaziso"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Ukukhawulelwa kwangokwezifiso"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Uma isikrini sivulekile"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Uma isikrini sivalekile"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Thulisa umsindo nokudlidliza"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Ungavuli isikrini"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Ungacwabizisi ukukhanya"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Ungavezi izaziso esikrinini"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Fihla izithonjana zebha yesimo ngaphezulu kwesikrini"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Fihla amachashazi esaziso kuzithonjana zohlelo lokusebenza"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Ungavuseli izaziso"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Fihla kusukela kumthunzi wokudonsela phansi"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Soze"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Uma isikrini sivaliwe"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Uma isikrini sivuliwe"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Umsindo nokudlidliza"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Umsindo, ukudlidliza, nezinye izimpawu zokubuka zezaziso"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Umsindo, ukudlidliza, nezimpawu zokubuka zezaziso"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="6403365663466620328">"Izaziso ziyadingeka kumsebenzi wefoni ovamile futhi isimo ngeke sifihlwe."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Lutho"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"okunye okungakhethwa"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Engeza"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Vula"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Vula manje"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Vala manje"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"Okuthi ungaphazamisi kuvuliwe kuze kube ngu-<xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"Okuthi Ungaphazamisi kuzohlala kuvuliwe uze ukuvale"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"Okuthi Ungaphazamisi kuvulwe ngokuzenzakalelayo ngeshejuli (<xliff:g id="RULE_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"Okuthi Ungaphazamisi kuvulwe ngokuzenzakalelayo ngohlelo lokusebenza (<xliff:g id="APP_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"Ukungaphazamisi kuvulelwe i-<xliff:g id="RULE_NAMES">%s</xliff:g> ngezilungiselelo zangokwezifiso."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="8255159194653341835">" "<annotation id="link">" Buka amasethingi angokwezifiso"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Okubalulekile kuphela"</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">"Kuvuliwe / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"Vuliwe"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Buza njalo"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Uze uvale isikrini"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{ihora eli-1}one{amahora #}other{amahora #}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{umzuzu 1}one{imizuzu #}other{imizuzu #}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Kuvaliwe}=1{Kuvaliwe ? ishejuli e-1 ingavula ngokuzenzakalelayo}one{Kuvaliwe / amashejuli angu-# angavula ngokuzenzakalelayo}other{Kuvaliwe / amashejuli angu-# angavula ngokuzenzakalelayo}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Yini engaphazamisa okuthi Ungaphazamisi"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Abantu"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Izinhlelo zokusebenza"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Ama-alamu nokunye ukuphazamiseka"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Amashejuli"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Ubude besikhathi sezilungiselelo ezisheshayo"</string>
    <string name="zen_settings_general" msgid="2704932194620124153">"Okuvamile"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Uma kuvulwe ukungaphazamisi, umsindo nokudlidliza kuzothuliswa, ngaphandle kwezinto ozivumela ngaphezulu."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Izilungiselelo zokwenza ngezifiso"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Buyekeza ishejuli"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"Ngiyezwa"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Izaziso"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Ubude besikhathi"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Imilayezo, imicimbi nezikhumbuzi"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"Uma kuvulwe ukungaphazamisi, imilayezo, izikhumbuzi, nemicimbi izothuliswa ngaphandle kwezinto ozivumela ngaphezulu. Ungalungisa izilungiselelo zemilayezo ukuze uvumele abangani bakho, umndeni, noma abanye oxhumana nabo bafinyelele kuwe."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Kwenziwe"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Izilungiselelo"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Akukho okubonakalayo noma umsindo kusukela kuzaziso"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Awukho umsindo kusukela kuzaziso"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"Ngeke ubone noma uzwe izaziso. Amakholi kusukela koxhumana nabo abafakwe inkanyezi nabafonayo abaphindiwe avunyelwe."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(Isilungiselelo samanje)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Shintsha izilungiselelo zokwazisa zokungaphazamisi?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Imisindo yephrofayela yomsebenzi"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Sebenzisa imisindo yephrofayela yomuntu siqu"</string>
    <string name="work_use_personal_sounds_summary" msgid="608061627969077231">"Sebenzisa imisindo efanayo nephrofayela yakho yomuntu siqu"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Ithoni yokukhala yefoni yomsebenzi"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Umsindo wesaziso somsebenzi ozenzakalelayo"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Umsindo we-alamu yomsebenzi yokuzenzakalelayo"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Ifana nephrofayela yomuntu siqu"</string>
    <string name="work_sync_dialog_title" msgid="7810248132303515469">"Sebenzisa imisindo yephrofayela yomuntu siqu?"</string>
    <string name="work_sync_dialog_yes" msgid="5785488304957707534">"Qinisekisa"</string>
    <string name="work_sync_dialog_message" msgid="5066178064994040223">"Iphrofayela yakho yomsebenzi izosebenzisa imisindo efanayo nephrofayela yakho yomuntu siqu"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Izaziso"</string>
    <string name="notification_dashboard_summary" msgid="7530169251902320652">"Umlando wezaziso, izingxoxo"</string>
    <string name="conversation_notifs_category" msgid="2549844862379963273">"Ingxoxo"</string>
    <string name="general_notification_header" msgid="3669031068980713359">"Phatha"</string>
    <string name="app_notification_field" msgid="3208079070539894909">"Izaziso ze-app"</string>
    <string name="app_notification_field_summary" msgid="5981393613897713471">"Lawula izaziso ezisuka kuma-app angawodwana"</string>
    <string name="advanced_section_header" msgid="6478709678084326738">"Okuvamile"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Izaziso zomsebenzi"</string>
    <string name="profile_section_header_for_advanced_privacy" msgid="8385775428904838579">"Iphrofayela yomsebenzi"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Ukubaluleka kwesaziso sokujwayela"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Setha ngokuzenzakalela izaziso zokubaluleka okuncane zibe Mnene"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Ukulinganisa kwesaziso sokujwayela"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Linganisa ngokuzenzakalelayo izaziso ngokuhlobana"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Impendulo yesaziso sokujwayela"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Bonisa ukulungiswa okwenziwe kuzaziso bese ubonisa inketho yokuhlinzeka ngempendulo kusistimu"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Setha kabusha ukubaluleka kwesaziso"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Setha kabusha amasethingi abalulekile ashintshiwe womsebenzisi bese uvumela umsizi wesaziso abe okubalulekile"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Izenzo eziphakanyisiwe nezimpendulo"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Bonisa ngokuzenzakalela izenzo eziphakanyisiwe nezimpendulo"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Bona izaziso zakamuva nezisnuziwe"</string>
    <string name="notification_history" msgid="8663811361243456201">"Umlando wesaziso"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Sebenzisa umlando wesaziso"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"Umlando wesaziso uvaliwe"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Vula umlando wesaziso ukubona izaziso zakamuva nezaziso ezisnuziwe"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Azikho izaziso zakamuva"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Izaziso zakho zakamuva nezisnuziwe zizovela lapha"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"buka izilungiselelo zesaziso"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"vula isaziso"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Vumela ukusnuza kwesaziso"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Ichashazi lesaziso kusithonjana sohlelo lokusebenza"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Amabhamuza"</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Amabhamuza"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Yenza ibhamuza le ngxoxo"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Bonisa isithonjana esintantayo ngaphezulu kwezinhlelo zokusebenza"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="1794193899792284007">"Vula amabhamuza wedivayisi?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"Ukuvula amabhamuza walolu hlelo kuzophinde futhi kuvule amabhamuza wedivayisi yakho.\n\nLokhu kuthinta ezinye izinhlelo zokusebenza noma izingxoxo ezivumelekile ukuba nebhamuza."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Vula"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Khansela"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Kuvuliwe / Izingxoxo zingavela njengezithonjana ezintantayo"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Vumela izinhlelo zokusebenza zibonise amabhamuza"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Ezinye izingxoxo zizovela njengezithonjana ezintantayo phezu kwezinye izinhlelo zokusebenza"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Zonke izingxoxo zingaba amabhamuza"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Izingxoxo ezikhethiwe zingaba amabhamuza"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Akukho okungaba yibhamuza"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Izingxoxo"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Zonke izingxoxo zingaba ibhamuza ngaphandle"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Vala amabhamuza wale ngxoxo"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Vula amabhamuza wale ngxoxo"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Swayiphela ngakwesokudla ukuze ucashise, ngakwesokunxele ukuze ubonise imenyu"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Swayiphela ngakwesokunxele ukuze ucashise, ngakwesokudla ukuze ubonise imenyu"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Fihla izaziso ezithulile kubha yesimo"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Cwabizisa ukukhanya"</string>
    <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Ubumfihlo"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Yeqa ukuze ukhiye isikrini"</string>
    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"Ngemuva kokuvula, iya ngokuqondile eskrinini sokugcina esisetshenzisiwe. Izaziso ngeke zivele esikrinini esikhiywe. Swayiphela phansi kusukela phezulu ukuze uzibone."</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Khiya isikrini, ukukhiya isikrini, yeqa, dlula"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Uma kukhiywe iphrofayela yomsebenzi"</string>
    <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Bonisa izaziso ezintsha kuphela esikrinini sokukhiya"</string>
    <string name="unseen_notifs_lock_screen_summary" msgid="5996722793868021391">"Sula ngokuzenzakalelayo izaziso ezibukwe ngaphambilini esikrinini sokukhiya"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Izaziso esikrinini sokukhiya"</string>
    <string name="lock_screen_notifs_show_all_summary" msgid="4226586018375762117">"Bonisa izingxoxo. ezizenzakalelayo, nezithulile"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Bonisa izingxoxo. ezizenzakalelayo, nezithulile"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Fihla izingxoxo ezithulile nezaziso"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Ungabonisi nhlobo izaziso"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Izaziso ezizwelayo"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Bonisa okuqukethwe okuzwelayo uma ikhiyiwe"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Izaziso zephrofayela yomsebenzi ozwelayo"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Bonisa okuqukethwe kwephrofayela yomsebenzi uma kukhiyiwe"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Bonisa konke okuqukethwe kwesaziso"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Bonisa okuqukethwe okuzwelayo kuphela uma kuvuliwe"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Ungabonisi izaziso nhlobo"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="6326229471276829730">"Ufuna ukuthi isikrini sakho sokuvala siboniseni?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Khiya isikrini"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Bonisa konke okuqukethwe kwesaziso somsebenzi"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Fihla okuqukethwe komsebenzi okuzwelayo"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"Uma idivayisi yakho ikhiyiwe, ufuna ukuthi izaziso zephrofayela zivele kanjani?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Izaziso zephrofayela"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Izaziso"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Izaziso zohlelo lokusebenza"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Isigaba sezaziso"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Ukuziphatha"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Izingxoxo"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Isigaba sengxoxo"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Vumela uhlelo lokusebenza ukusebenzisa isigaba sengxoxo"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Akuyona ingxoxo"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Susa kusuka kwisigaba sengxoxo"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"Lena ingxoxo"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Engeza esigabeni sengxoxo"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"Azikho izingxoxo ezibalulekile"</string>
    <string name="priority_conversation_count" msgid="7291234530844412077">"{count,plural, =1{Ingxoxo engu-# ebalulekile}one{Izingxoxo ezingu-# ezibalulekile}other{Izingxoxo ezingu-# ezibalulekile}}"</string>
    <string name="important_conversations" msgid="1233893707189659401">"Izingxoxo ezibalulekile"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Zibonakala ngaphezulu kwesigaba sengxoxo futhi zivela njengamabhamuza antantayo"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Kubonakala esigabeni esiphezulu sengxoxo"</string>
    <string name="other_conversations" msgid="551178916855139870">"Akuzona izingxoxo ezibalulekile"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Izingxoxo owenze izinguquko kuzo"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Izingxoxo zakamuva"</string>
    <string name="conversation_settings_clear_recents" msgid="8940398397663307054">"Sula izingxoxo zakamuva"</string>
    <string name="recent_convos_removed" msgid="2122932798895714203">"Izingxoxo zakamuva zisusiwe"</string>
    <string name="recent_convo_removed" msgid="8686414146325958281">"Ingxoxo isusiwe"</string>
    <string name="clear" msgid="5092178335409471100">"Sula"</string>
    <string name="clear_conversation" msgid="5564321180363279096">"Sula i-<xliff:g id="CONVERSATION_NAME">%1$s</xliff:g>"</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Izingxoxo ezibalulekile neziguquliwe zizovela lapha"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Lapho usumaka ingxoxo njengebalulekile, noma wenza ezinye izinguquko ezingxoxweni, zizovela lapha. \n\nUkushintsha izilungiselelo zengxoxo: \nSwayipha ngezansi kusuka ngaphezulu kwesikrini ukuvula ukudonsela phansi umthunzi, bese uthinta futhi ubambe ingxoxo."</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Nciphisa"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"I-pop kusikrini"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Kuthulile"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Okuzenzekelayo"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Vumela ukuphazamisa"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"Vumela uhlelo lokusebenza ukwenza umsindo, ukudlidliza, kanye/noma izaziso ezivela esikrinini"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Okubalulekile"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Iboniswa ngenhla kwesigaba sengxoxo, ivela njengebhamuza elintantayo, ibonisa isithombe sephrofayela kukukhiya isikrini"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"I-<xliff:g id="APP_NAME">%1$s</xliff:g> ayisekeli izici eziningi zengxoxo. Awukwazi ukusetha ingxoxo njengebalulekile, futh izingxoxo ngeke zivele njengamabhamuza antantayo."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"Emthunzini wokudonsela phansi, goqa izaziso emugqeni owodwa"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Awukho umsindo noma ukudlidliza"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"Awukho umsindo noma ukudlidliza futhi ivela ngezansi esigabeni sengxoxo"</string>
    <string name="notification_channel_summary_default" msgid="1168420867670390611">"Ingase ikhale noma idlidlize ngokusekelwe kumasethingi edivayisi"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Uma idivayisi ivuliwe, bonisa izaziso njengesibhengezo ngaphezulu kwesikrini"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"Zonke izaziso ze-\"<xliff:g id="APP_NAME">%1$s</xliff:g>\""</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Zonke izaziso ze-<xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="notifications_sent_daily" msgid="10274479224185437">"{count,plural, =1{Cishe isaziso esingu-# ngosuku}one{Cishe izaziso ezingu-# ngosuku}other{Cishe izaziso ezingu-# ngosuku}}"</string>
    <string name="notifications_sent_weekly" msgid="7895656213187555346">"{count,plural, =1{Cishe isaziso esingu-# ngeviki}one{Cishe izaziso ezingu-# ngeviki}other{Cishe izaziso ezingu-# ngeviki}}"</string>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Soze"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Idivayisi nezaziso ze-app"</string>
    <string name="manage_notification_access_summary" msgid="2907135226478903997">"Lawula ukuthi yimaphi ama-app namadivayisi angafunda izaziso"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"Ukufinyelela kuzaziso zephrofayela yomsebenzi zivinjelwe"</string>
    <string name="notification_assistant_title" msgid="5889201903272393099">"Izaziso ezindisiwe"</string>
    <string name="notification_assistant_summary" msgid="1957783114840908887">"Thola izenzo eziphakanyisiwe, izimpenulo, nokuningi"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Lutho"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Azikho izinhlelo zokusebenza ezicele ukufinyelela kwesaziso."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Vumela ukufinyelela kwesaziso"</string>
    <string name="notification_assistant_security_warning_summary" msgid="4846559755787348129">"Izaziso ezandisiwe zithathe isikhundla sezaziso eziguqukayo ze-Android ku-Android 12. Lesi sici sikhombisa izenzo eziphakanyisiwe nezimpendulo, futhi sihlela izaziso zakho \n\nIzaziso ezandisiwe zingafinyelela kokuqukethwe kwesaziso, kuhlanganise nemininingwane yomuntu efana namagama woxhumana nabo nemilayezo. Lesi sakhi singacashisa noma siphendule izaziso, njengokuphendula amakholi wefoni, nokulawula okuthi Ungaphazamisi."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Vumela ukufinyelela kwe-<xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1131986567509818121">"I-<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> izokwazi ukufunda zonke izaziso, okufaka phakathi ulwazi lomuntu siqu njengamagama woxhumana nabo, izithombe, nemiyalezo yombhalo oyitholayo. Le app izokwazi futhi ukusnuza noma ukucashisa izaziso noma ukwenza isenzo kwizinkinobho ezikuzaziso, okufaka phakathi ukuphendula amakholi wefoni. \n\nLokhu kuzonikeza futhi uhlelo lokusebenza ikhono lokuvula noma ukuvala okuthi Ungaphazamisi nokushintsha amasethingi ahambisanayo."</string>
    <string name="nls_warning_prompt" msgid="1486887096703743841">"I-app ye-<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> izokwazi:"</string>
    <string name="nls_feature_read_title" msgid="7629713268744220437">"Funda izaziso zakho"</string>
    <string name="nls_feature_read_summary" msgid="1064698238110273593">"Ingafunda izaziso zakho, okuhlanganisa ulwazi lomuntu siqu olufana noxhumana nabo, imilayezo, nezithombe."</string>
    <string name="nls_feature_reply_title" msgid="7925455553821362039">"Phendula imilayezo"</string>
    <string name="nls_feature_reply_summary" msgid="4492543411395565556">"Ingakwazi ukuphendula imilayezo futhi ithathe isinyathelo kuzinkinobho zezaziso, okuhlanganisa ukusnuza noma ukucashisa izaziso nokuphendula amakholi."</string>
    <string name="nls_feature_settings_title" msgid="8208164329853194414">"Shintsha amasethingi"</string>
    <string name="nls_feature_settings_summary" msgid="3770028705648985689">"Ingakwazi ukuvula noma ukuvala okuthi Ungaphazamisi futhi iguqule amasethingi ahlobene."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Uma uvala ukufinyelela kwezaziso kwe-<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>, Ukufinyelela kokuthi ungaphazamisi nakho kungavalwa."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Vala"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Khansela"</string>
    <string name="notif_type_ongoing" msgid="135675014223627555">"Isikhathi sangempela"</string>
    <string name="notif_type_ongoing_summary" msgid="2348867528527573574">"Ingxoxo eqhubekayo evela kuma-app asetshenziswayo, ukuzulazula, amakholi wefoni, nokuningi"</string>
    <string name="notif_type_conversation" msgid="4383931408641374979">"Izingxoxo"</string>
    <string name="notif_type_conversation_summary" msgid="179142405410217101">"I-SMS, imibhalo yomlayezo, nokunye ukuxhumana"</string>
    <string name="notif_type_alerting" msgid="4713073696855718576">"Izaziso"</string>
    <string name="notif_type_alerting_summary" msgid="4681068287836313604">"Ingase ikhale noma idlidlize ngokusekelwe kumasethingi"</string>
    <string name="notif_type_silent" msgid="6273951794420331010">"Kuthulile"</string>
    <string name="notif_type_silent_summary" msgid="7820923063105060844">"Izaziso ezingalokothi zenze umsindo noma ukudlidliza"</string>
    <string name="notification_listener_allowed" msgid="5536962633536318551">"Kuvumelekile"</string>
    <string name="notification_listener_not_allowed" msgid="3352962779597846538">"Akuvumelekile"</string>
    <string name="notif_listener_excluded_app_title" msgid="6679316209330349730">"Bona wonke ama-app"</string>
    <string name="notif_listener_excluded_app_summary" msgid="2914567678047195396">"Shintsha amasethingi we-app ngayinye ethumela izaziso"</string>
    <string name="notif_listener_excluded_app_screen_title" msgid="8636196723227432994">"Ama-app aboniswe kudivayisi"</string>
    <string name="notif_listener_not_migrated" msgid="6265206376374278226">"Le app ayisekeli amasethingi athuthukisiwe"</string>
    <string name="notif_listener_more_settings" msgid="1348409392307208921">"Amanye amasethingi"</string>
    <string name="notif_listener_more_settings_desc" msgid="7995492074281663658">"Amasethingi engeziwe ayatholakala ngaphakathi kwale app"</string>
    <string name="notification_polite_title" msgid="6121016426991791557">"Isikhathi sokuphola sezaziso"</string>
    <string name="notification_polite_all_apps" msgid="1118651561594250059">"Faka isikhathi sokuphola kuzo zonke izaziso"</string>
    <string name="notification_polite_all_apps_summary" msgid="540268373207498126">"Yehlisa kancane kancane ivolumu yezaziso uma uthola izaziso eziningi ezilandelanayo ku-app eyodwa"</string>
    <string name="notification_polite_conversations" msgid="8197695136727245741">"Faka isikhathi sokuphola ezingxoxweni"</string>
    <string name="notification_polite_conversations_summary" msgid="2677141765664359994">"Yehlisa kancane kancane ivolumu yezaziso uma uthola imilayezo eminingi elandelanayo engxoxweni eyodwa phakathi nesikhathi esifushane"</string>
    <string name="notification_polite_disabled" msgid="1378078021594282842">"Ungasisebenzisi isikhathi sokuphola sezaziso"</string>
    <string name="notification_polite_disabled_summary" msgid="1145341260283746936">"Ungalokothi wehlise ivolumu yezaziso, kungakhathaliseki ukuthi zingaki izaziso ezingena zilandelana zivela ku-app eyodwa"</string>
    <string name="notification_polite_vibrate_unlocked" msgid="6142573851761357903">"Dlidliza uma ivulwa"</string>
    <string name="notification_polite_vibrate_unlocked_summary" msgid="1678472892282874459">"Dlidliza kuphela uma isikrini sivulwa"</string>
    <string name="notification_polite_work" msgid="8823596456640216391">"Sebenzisa kumaphrofayela omsebenzi"</string>
    <string name="notification_polite_work_summary" msgid="8260947839104352075">"Sebenzisa amasethingi okuphola kwezaziso kuphrofayela yakho eqondene nawe nakuphrofayela yakho yomsebenzi"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"Amasevisi omsizi we-VR"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Azikho izinhlelo zokusebenza ezifakiwe ezicele ukusetshenziswa njengamasevisi wesisizi se-VR."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"Vumela isevisi ye-VR ukufinyelela i-<xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"I-<xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> izokwazi ukusebenza uma usebenzisa izinhlelo zokusebenza kumodi yokubonakalayo kwangempela."</string>
    <string name="display_vr_pref_title" msgid="4850474436291113569">"Uma idivayisi iku-VR"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Yehlisa ukufiphala (kunconyiwe)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Yehlisa i-flicker"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Isithombe-phakathi-kwesithombe"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Azikho izinhlelo zokusebenza ezifakiwe ezisekela isithombe phakathi kwesithombe"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"yenza i-pip kusithombe esiku-"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Isithombe-phakathi-kwesithombe"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Vumela isithombe phakathi kwesithombe"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Vumela lolu hlelo lokusebenza ukuthi ludale iwindi lesithombe ngaphakathi kwesithombe ngenkathi uhlelo lokusebenza luvuliwe noma ngemuva kokuthi ulishiye (isibonelo, ukuze uqhubeke ubuke ividiyo). Leli windi liboniswa ngaphezulu kwezinye izinhlelo zokusebenza ozisebenzisayo."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Izinhlelo zokusebenza ezixhunyiwe zomsebenzi nezomuntu siqu"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Ixhunyiwe"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Akuxhunyiwe"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"Azikho izinhlelo zokusebenza ezixhunyiwe"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"Ama-app ephrofayela eliphanjanisiwe e-app nawomuntu siqu"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Kuxhunyiwe"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Xhuma lezi zinhlelo zokusebenza"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Izinhlelo zokusebenza ezixhunywe zabelana ngezimvume futhi zingafinyelela idatha ephakathi kwazo."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Xhuma kuphela izinhlelo zokusebenza uma uzethemba ukuthi ngeke zabelane ngedatha yakho yomuntu siqu nomphathi wakho we-IT."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Unganqamula izinhlelo zokusebenza noma nini kumasethingi emfihlo kudivayisi yakho."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Uyawuthemba umsebenzi we-<xliff:g id="NAME">%1$s</xliff:g> ngedatha yakho yomuntu siqu?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Xhuma kuphela izinhlelo zokusebenza uma uzethemba ukuthi ngeke zabelane ngedatha yakho yomuntu siqu nomphathi wakho we-IT."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"Idatha yohlelo lokusebenza"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Lolu hlelo lokusebenza lungafinyelela idatha ekulolu hlelo lokusebenza lwakho lomuntu siqu le-<xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Izimvume"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Lolu hlelo lokusebenza lungasebenzisa izimvume zohlelo lokusebenza lakho siqu le-<xliff:g id="NAME">%1$s</xliff:g>, njengokufinyelela indawo, isitoreji, noma oxhumana nabo."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Akukho zinhlelo zokusebenza ezixhunyiwe"</string>
    <string name="interact_across_profiles_number_of_connected_apps" msgid="4000424798291479207">"{count,plural, =1{I-app engu-# ixhunyiwe}one{Ama-app angu-# axhunyiwe}other{Ama-app angu-# axhunyiwe}}"</string>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Ukuxhuma la ma-app, faka u-<xliff:g id="NAME">%1$s</xliff:g> kuphrofayela yakho yomsebenzi"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Ukuxhuma lama app, faka u-<xliff:g id="NAME">%1$s</xliff:g> kuphrofayela yakho yomuntu siqu."</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Thepha ukuthola uhlelo lokusebenza"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Ukufinyelela kokungaphazamisi"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Vumela ukungaphazamisi"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Azikho izinhlelo zokusebenza ezifakiwe ezicele ukufinyelela kokungaphazamisi"</string>
    <string name="app_notifications_off_desc" msgid="2484843759466874201">"Awukavumeli izaziso ezivela kule-app"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"Ngokwesicelo sakho i-Android ivimbela lesi sigaba sezaziso kusukela ekuveleni kule divayisi"</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"Ngokwesicelo sakho i-Android ivimbela leli qembu lezaziso kusukela ekuveleni kule divayisi"</string>
    <string name="app_notifications_not_send_desc" msgid="5683060986735070528">"Le app ayithumeli izaziso"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Izigaba"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Okunye"</string>
    <string name="no_channels" msgid="4716199078612071915">"le-app ayizange ithumele izasiso"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Amasethingi angeziwe ku-app"</string>
    <string name="show_unused_channels" msgid="2754356124204058828">"Bonisa iziteshi ezingasetshenzisiwe"</string>
    <string name="hide_unused_channels" msgid="9049958190570733200">"Fihla iziteshi ezingasetshenzisiwe"</string>
    <string name="deleted_channels" msgid="8489800381509312964">"{count,plural, =1{Isigaba esingu-# sisuliwe}one{Izigaba ezingu-# zisuliwe}other{Izigaba ezingu-# zisuliwe}}"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Vimbela konke"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Ungalokothi ubonise lezi zaziso"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Bonisa izaziso"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Ungalokothi ubonise izaziso kumthunzi noma kumadivayisi alawulwa ikhompuyutha"</string>
    <string name="app_notification_fsi_permission_title" msgid="5424116606034705020">"Vumela izaziso zesikrini esigcwele"</string>
    <string name="app_notification_fsi_permission_summary" msgid="7673487977631068039">"Vumela izaziso ukuthi zithathe isikrini esigcwele uma idivayisi ikhiyiwe"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Vumela ichashazi lesaziso"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Bonisa ichashazi lesaziso"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Susa Ukungaphazamisi"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Vumela lezi zaziso ziqhubeke ziphazamise uma Ukungaphazamisi kuvuliwe"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Khiya isikrini"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Kwenziwe"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Cwabizisa ukukhanya"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Ukudlidliza"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Umsindo"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Okubalulekile"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Igama leshejuli"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Faka igama leshejuli"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"Igama leshejuli selivele likhona"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Engeza okuningi"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Engeza ishejuli yomcimbi"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Engeza ishejuli yesikhathi"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Khetha uhlobo leshejuli"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Susa isimiso se-\"<xliff:g id="RULE">%1$s</xliff:g>\"?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Susa"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"Lezi zilungiselelo azikwazi ukushintshwa manje manje. Uhlelo lokusebenza (<xliff:g id="APP_NAME">%1$s</xliff:g>) livuleke ngokuzenzakalelayo kokuthi Ungaphazamisi ngokusebenza kwangezifiso."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"Lezi zilungiselelo azikwazi ukushintshwa manje manje. Uhlelo lokusebenza livuleke ngokuzenzakalelayo kokuthi Ungaphazamisi ngokusebenza kwangezifiso."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"Lezi zilungiselelo azikwazi ukushintshwa manje. Okuthi Ungaphazamisi kuvulwe ngokwenza ngokusebenza kwangezifiso."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Isikhathi"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Umcimbi"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Ngesikhathi semicimbi ye-"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"Noma iyiphi ikhalenda"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"Lapho impendulo ingu-"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"Yebo, Mhlawumbe, noma Akuphenduliwe"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"Yebo noma Mhlawumbe"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Yebo"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Isimiso asitholiwe."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"Kuvuliwe / <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">"Izinsuku"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Lutho"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"I-alamu ingakhipha isikhathi sokugcina"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Ishejuli iyavaleka uma i-alamu ikhala"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Impatho yokungaphazamisi"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Sebenzisa izilungiselelo ezizenzakalelayo"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Dala izilungiselelo zangokwezifiso zale shejuli"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"Okwe-‘<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">"Izingxoxo"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"Zonke izingxoxo"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Izingxoxo ezibalulekile"</string>
    <string name="zen_mode_from_important_conversations_second" msgid="7588299891972136599">"izingxoxo ezibalulekile"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Lutho"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Lutho}=1{ingxoxo e-1}one{izingxoxo ezingu-#}other{izingxoxo ezingu-#}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Labo abangaphazamisa"</string>
    <string name="zen_mode_people_footer" msgid="7710707353004137431">"Ngisho noma ama-app okulayeza noma okufona engakwazi ukukwazisa, abantu obakhetha lapha basengakuthola ngalawo ma-app"</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Amakholi"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Amakholi"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"amakholi"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Amakholi angaphazamisa"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"Ukuqinisekisa ukuthi amakholi avunyelwe enza umsindo, hlola ukuthi idivayisi isethelwe ukukhalisa"</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"Okwe-‘<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>’ kwamakholi angenayo kuvinjelwe. Ungalungisa izilungiselelo ukuze uvumele abangani bakho, umndeni, noma abanye oxhumana nabo ukuthi bafinyelele kuwe."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Oxhumana nabo abafakwe inkanyezi"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Lutho}=1{{contact_1}}=2{U-{contact_1} no-{contact_2}}=3{U-{contact_1}, {contact_2}, no-{contact_3}}one{U-{contact_1}, {contact_2}, nabanye abangu-#}other{U-{contact_1}, {contact_2}, nabanye abangu-#}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Alikho igama)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Imilayezo"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"imilayezo"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Imilayezo"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Imilayezo engaphazamisa"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"Ukuqinisekisa ukuthi imilayezo evunyelwe yenza umsindo, hlola ukuthi idivayisi isethelwe ukukhalisa"</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"Okwemilayezo engenayo ye-\'<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\' evinjiwe. Ungalungisa izilungiselelo ukuze uvumele abangani bakho, umndeni, noma abanye oxhumana nabo ukuthi bafinyelele kuwe."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Yonke imilayezo ingafinyelela kuwe"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Wonke amakholi angafinyelela kuwe"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Lutho}=1{oxhumana naye o-1}one{oxhumana nabo abangu-#}other{oxhumana nabo abangu-#}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Noma ubani"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Oxhumana nabo"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Oxhumana nabo abafakwe inkanyezi"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Lutho"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Lutho"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Ama-alamu"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"Kusukela kuzibali sikhathi, ama-alamu, amasistimu okuvikela, nezinye izinhlelo zokusebenza"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"ama-alamu"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Ama-alamu"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Imisindo yemidiya"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Imisindo esuka kumavidiyo, amageyimu, nenye imidiya"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"imidiya"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Imidiya"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Imisindo yokuthinta"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Imisindo esuka kukhibhodi nezinye izinkinobho"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"imisindo yokuthinta"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Imisindo yokuthinta"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Izikhumbuzi"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"Kusukela kumisebenzi nezikhumbuzi"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"izikhumbuzi"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Izikhumbuzi"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Imicimbi yekhalenda"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"Kusukela kumicimbi yekhalenda ezayo"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"imicimbi"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"Imicimbi"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Vumela izinhlelo zokusebenza ukubhala ngaphezulu"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Ama-app angaphazamisa"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Khetha izinhlelo zokusebenza eziningi"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Awekho ama-app akhethiwe"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Awekho ama-app angaphazamisa"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Engeza izinhlelo zokusebenza"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Zonke izaziso"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Ezinye izaziso"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Abantu abakhethiwe basengakuthola, ngisho noma ungavumeli izinhlelo zokusebenza ukuphazamisa"</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Azikho izinhlelo zokusebenza ezingaphazamisa}=1{I-{app_1} ingaphazamisa}=2{I-{app_1} ne-{app_2} zingaphazamisa}=3{I-{app_1}, i-{app_2}, ne-{app_3} zingaphazamisa}one{I-{app_1}, i-{app_2}, kanye nezingu-# ezengeziwe zingaphazamisa}other{I-{app_1}, i-{app_2}, kanye nezingu-# ezengeziwe zingaphazamisa}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Izinhlelo zokusebenza"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Izaziso ezingaphazamisa"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Vumela zonke izaziso"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Akukho okungaphazamisa}=1{I-{sound_category_1} ingaphazamisa}=2{I-{sound_category_1} ne-{sound_category_2} zingaphazamisa}=3{I-{sound_category_1}, i-{sound_category_2}, ne-{sound_category_3} zingaphazamisa}one{I-{sound_category_1}, i-{sound_category_2}, kanye nezingu-# ezengeziwe zingaphazamisa}other{I-{sound_category_1}, i-{sound_category_2}, kanye nezingu-# ezengeziwe zingaphazamisa}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Akukho okungaphazamisa"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Akekho ongaphazamisa"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Abantu abathile bangaphazamisa"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Bonke abantu bangaphazamisa"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Phinda abafonayo"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Vumela abashayi abaphindayo"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"noma ubani"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"oxhumana nabo"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"oxhumana nabo abanenkanyezi"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"phinda abafonayo"</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> ne-<xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"Uma umuntu ofanayo enza ikholi okwesibili phakathi nenkathi yamaminithi angu-<xliff:g id="MINUTES">%d</xliff:g>"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Isikhathi sokuqala"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Isikhathi sokugcina"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> usuku olulandelayo"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Guqulela kuma-alamu kuphela unaphakade"</string>
    <string name="zen_mode_summary_alarms_only_by_minute" msgid="6673649005494939311">"{count,plural, =1{Shintshela kuma-alamu umzuzu owodwa kuze kube {time}}one{Shintshela kuma-alamu kuphela imizuzu engu-# (kuze kube {time})}other{Shintshela kuma-alamu kuphela imizuzu engu-# (kuze kube {time})}}"</string>
    <string name="zen_mode_summary_alarms_only_by_hour" msgid="7400910210950788163">"{count,plural, =1{Shintshela kuma-alamu ihora elilodwa kuze kube {time}}one{Shintshela kuma-alamu kuphela amahora angu-# (kuze kube {time})}other{Shintshela kuma-alamu kuphela amahora angu-# (kuze kube {time})}}"</string>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Guqulela kuma-alamu kuphela kuze kube ngumhla ka-<xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Guqulela kuhlala uphazamisa"</string>
    <string name="warning_button_text" msgid="1274234338874005639">"Isexwayiso"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Vala"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Thumela impendulo mayelana nale divayisi"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Faka iphinikhodi yomlawuli"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"Vuliwe"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Valiwe"</string>
    <string name="nfc_setting_on" msgid="7701896496026725772">"Vuliwe"</string>
    <string name="nfc_setting_off" msgid="7142103438532732309">"Valiwe"</string>
    <string name="screen_pinning_switch_on_text" msgid="6971386830247542552">"Vuliwe"</string>
    <string name="screen_pinning_switch_off_text" msgid="5032105155623003875">"Valiwe"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Ukuphina i-app"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"Ukuphina uhlelo lokusebenza kukuvumela ukuba ugcine uhlelo lokusebenza lwamanje lubhekiwe kuze kube yilapho ususa ukuphina kulo. Lesi sici singasetshenziswa, njengesibonelo, ukuvumela umngani othenjiwe ukuthi adlale igeyimu ethile."</string>
    <string name="screen_pinning_description" msgid="5822120806426139396">"Uma i-app iphiniwe, i-app ephiniwe ingavula amanye ama-app futhi idatha yomuntu siqu ingase ifinyeleleke. \n\nUkuze usebenzise ukuphina i-app: 	\n{0,number,integer}. Vula ukuphina i-app 	\n{1,number,integer}. Vula Isifinyezo 	\n{2,number,integer}. Thepha isithonjana se-app phezulu esikrinini, bese uthepha okuthi Phina"</string>
    <string name="screen_pinning_guest_user_description" msgid="2307270321127139579">"Uma i-app iphiniwe, i-app ephiniwe ingavula amanye ama-app futhi idatha yomuntu siqu ingase ifinyeleleke. \n\nUma ufuna ukwabelana nothile ngokuphephile ngedivayisi yakho, kunalokho zama ukusebenzisa umsebenzisi wesimenywa. \n\nUkuze usebenzise ukuphina i-app: 	\n{0,number,integer}. Vula ukuphina i-app 	\n{1,number,integer}. Vula Isifinyezo 	\n{2,number,integer}. Thepha isithonjana se-app phezulu esikrinini, bese uthepha okuthi Phina"</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Uma i-app iphiniwe: \n\n•		Idatha yomuntu siqu ingafinyeleleka \n		(njengoxhumana nabo kanye nokuqukethwe ku-imeyili) \n•		Uhlelo lokusebenza oluphiniwe lungavula amanye ama-app \n\nSebenzisa ukuphina ama-app nabantu obathembayo kuphela."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Cela iphethini yokuvula ngaphambi kokususa ukuphina"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Cela iphinikhodi ngaphambi kokuphina"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Cela iphasiwedi ngaphambi kokususa ukuphina"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Khiya idivayisi uma ususa ukuphina"</string>
    <string name="confirm_sim_deletion_title" msgid="7262127071183428893">"Qinisekisa ukuthi ufuna ukusula i-eSIM yakho"</string>
    <string name="confirm_sim_deletion_description" msgid="4439657901673639063">"Qinisekisa ukuthi nguwe ngaphambi kokusula i-eSIM"</string>
    <string name="memtag_title" msgid="5096176296797727201">"I-beta yokuvikela inkumbulo ethuthukisiwe"</string>
    <string name="memtag_toggle" msgid="8695028758462939212">"Ukuvikelwa kwenkumbulo okuthuthukisiwe"</string>
    <string name="memtag_intro" msgid="579408691329568953">"Lesi sakhi se-beta sikusiza ukuthi uvikele idivayisi yakho kuziphazamisi ezingase zibeke ukuphepha kwakho engcupheni."</string>
    <string name="memtag_on" msgid="824938319141503923">"Vuliwe"</string>
    <string name="memtag_off" msgid="4835589640091709019">"Valiwe"</string>
    <string name="memtag_on_pending" msgid="1592053425431532361">"Ivuliwe ngemva kokuqala kabusha"</string>
    <string name="memtag_off_pending" msgid="1543177181383593726">"Vala ngemva kokuqala kabusha"</string>
    <string name="memtag_force_off" msgid="1143468955988138470">"Manje ayitholakali kudivayisi yakho"</string>
    <string name="memtag_force_on" msgid="3254349938627883664">"Ihlala ivuliwe kudivayisi yakho"</string>
    <string name="memtag_footer" msgid="8480784485124271376">"Kuzodingeka uqalise kabusha idivayisi yakho ukuze uvule noma uvale ukuvikelwa kwenkumbulo Okuthuthukisiwe. Uma ivuliwe, ungase ubone ukusebenza kwedivayisi kuhamba kancane."</string>
    <string name="memtag_reboot_title" msgid="1413471876903578769">"Qalisa kabusha idivayisi?"</string>
    <string name="memtag_reboot_message_on" msgid="3270256606602439418">"Uzodinga ukuqala kabusha idivayisi yakho ukuze uvule ukuvikelwa kwenkumbulo Okuthuthukisiwe."</string>
    <string name="memtag_reboot_message_off" msgid="2567062468140476451">"Uzodinga ukuqala kabusha idivayisi yakho ukuze uvale ukuvikelwa kwememori Okuthuthukisiwe."</string>
    <string name="memtag_reboot_yes" msgid="5788896350697141429">"Qala kabusha"</string>
    <string name="memtag_reboot_no" msgid="2860671356184849330">"Hhayi manje"</string>
    <string name="memtag_learn_more" msgid="1596145970669119776">"Funda kabanzi mayelana nokuvikela inkumbulo Okuthuthukisiwe."</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"Le phrofayela yomsebenzi iphethwe ngu:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Iphethwe ngu-<xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Vula ngokuzenzekelayo"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Vula izixhumanisi ezisekelwayo"</string>
    <string name="app_launch_top_intro_message" msgid="137370923637482459">"Vumela amalinki wewebhu ukuba avule le-app"</string>
    <string name="app_launch_links_category" msgid="2380467163878760037">"Izixhumanisi zokuvula le app"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Izixhumanisi ezisekelwayo"</string>
    <string name="app_launch_other_defaults_title" msgid="5674385877838735586">"Okunye okuncanyelwayo okuzenzakalelayo"</string>
    <string name="app_launch_add_link" msgid="8622558044530305811">"Engeza isixhumanisi"</string>
    <string name="app_launch_footer" msgid="4521865035105622557">"I-app ingaqinisekisa amalinki ukuvula ngokuzenzekelayo ku-app"</string>
    <string name="app_launch_verified_links_title" msgid="621908751569155356">"{count,plural, =1{# ilinki yokuqinisekisa}one{# amalinki aqinisekisiwe}other{# amalinki aqinisekisiwe}}"</string>
    <string name="app_launch_verified_links_message" msgid="190871133877476176">"{count,plural, =1{Lesi sixhumanisi siqinisekisiwe futhi sivula le app ngokuzenzakalelayo.}one{Lezi zixhumanisi ziqinisekisiwe futhi zivula le app ngokuzenzakalelayo.}other{Lezi zixhumanisi ziqinisekisiwe futhi zivula le app ngokuzenzakalelayo.}}"</string>
    <string name="app_launch_dialog_ok" msgid="1446157681861409861">"KULUNGILE"</string>
    <string name="app_launch_verified_links_info_description" msgid="7514750232467132117">"Bonisa uhlu lwezixhumanisi zokuqinisekisa"</string>
    <string name="app_launch_checking_links_title" msgid="6119228853554114201">"Ihlola ezinye izixhumanisi ezisekelwayo…"</string>
    <string name="app_launch_dialog_cancel" msgid="6961071841814898663">"Khansela"</string>
    <string name="app_launch_supported_links_title" msgid="2457931321701095763">"{count,plural, =1{# ilinki yosekelo}one{# amalinki ezisekelo}other{# amalinki ezisekelo}}"</string>
    <string name="app_launch_supported_links_add" msgid="3271247750388016131">"Engeza"</string>
    <string name="app_launch_supported_links_subtext" msgid="4268004019469184113">"Ivula ngomhla ka-<xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"<xliff:g id="SIZE">%1$s</xliff:g> isetshenziwe ku-<xliff:g id="STORAGE_TYPE">%2$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="979243131665635278">"isitoreji sangaphakathi"</string>
    <string name="storage_type_external" msgid="125078274000280821">"isitoreji sangaphandle"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"<xliff:g id="SIZE">%1$s</xliff:g> esetshenzisiwe kusukela ngomhla ka-<xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="2591194906751432725">"Isitoreji esisetshenzisiwe"</string>
    <string name="change" msgid="273206077375322595">"Guqula"</string>
    <string name="change_storage" msgid="8773820275624113401">"Guqula isitoreji"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Izaziso"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"Vuliwe"</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">"Valiwe"</string>
    <string name="notifications_categories_off" msgid="7712037485557237328">"{count,plural, =1{# isigaba sivaliwe}one{# izigaba zivaliwe}other{# izigaba zivaliwe}}"</string>
    <string name="runtime_permissions_additional_count" msgid="6071909675951786523">"{count,plural, =1{imvume engeziwe engu-#}one{izimvume ezingeziwe ezingu-#}other{izimvume ezingeziwe ezingu-#}}"</string>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"Azikho izimvume ezinikiwe"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Azikho izimvume eziceliwe"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Lawula ukufinyelela kwi-app kudatha yakho"</string>
    <string name="permissions_usage_title" msgid="2942741460679049132">"Ideshibhodi yobumfihlo"</string>
    <string name="permissions_usage_summary" msgid="6784310472062516454">"Bonisa ukuthi yimaphi ama-app asebenzise izimvume muva nje"</string>
    <string name="unused_apps" msgid="4566272194756830656">"Ama-unused app"</string>
    <string name="unused_apps_summary" msgid="4236371818881973021">"{count,plural, =1{i-app engasetshenzisiwe engu-#}one{Ama-app angasetshenzisiwe angu-#}other{Ama-app angasetshenzisiwe angu-#}}"</string>
    <string name="unused_apps_category" msgid="8954930958175500851">"Amasethingi we-app engasetshenziswanga"</string>
    <string name="unused_apps_switch" msgid="7595419855882245772">"Misa okwesikhashana umsebenzi we-app uma ingasetshenziswa"</string>
    <string name="unused_apps_switch_summary" msgid="2171098908014596802">"Susa izimvume, sula amafayela wesikhashana, futhi umise izaziso"</string>
    <string name="unused_apps_switch_v2" msgid="7464060328451454469">"Lawula i-app uma ingasetsheziswa"</string>
    <string name="unused_apps_switch_summary_v2" msgid="3182898279622036805">"Susa izimvume, sula amafayela esikhashana, futhi ufake i-app kungobo yomlando"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Zonke izinhlelo zokusebenza"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Izinhlelo zokusebenza ezifakiwe"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Izinhlelo zokusebenza ezisheshayo"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Vala"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Okuthuthukisiwe"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Isiphathi semvume"</string>
    <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"Izibuyekezo zokwabelana ngedatha zendawo"</string>
    <string name="app_data_sharing_updates_summary" msgid="4465929918457739443">"Buyekeza ama-app aguqule indlela angabelana ngayo ngedatha yendawo yakho"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Thepha ukuze uvuse"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Thepha kabili noma yikuphi kusikrini ukuze uvuse idivayisi"</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Ivula amalinki"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Ungavuli izixhumanisi ezisekelwayo"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Vula i-<xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Vula i-<xliff:g id="DOMAIN">%s</xliff:g> namanye ama-URL"</string>
    <string name="app_link_open_always" msgid="9167065494930657503">"Vumela uhlelo lokusebenza ukuthi luvule izixhumanisi ezisekwelwe"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Buza njalo"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Ungavumeli uhlelo lokusebenza ukuthi luvule izixhumanisi"</string>
    <string name="app_link_open_always_summary" msgid="4524005594295855117">"{count,plural, =1{Uhlelo lokusebenza luthi luphethe isixhumanisi esingu-#}one{Uhlelo lokusebenza luthi luphethe izixhumanisi ezingu-#}other{Uhlelo lokusebenza luthi luphethe izixhumanisi ezingu-#}}"</string>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"Uhlelo lokusebenza luthi luphele izixhumanisi ezilandelayo:"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Okokufaka kwensiza nezwi"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"I-app yomsizi wedijithali"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"I-app yomsizi wedijithali ezenzekelayo"</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Vuma"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"I-app yesiphequluli"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Uhlelo lokusebenza lwefoni"</string>
    <string name="system_app" msgid="1863291702508355041">"(Isistimu)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Isitoreji sezinhlelo zokusebenza"</string>
    <string name="usage_access" msgid="5487993885373893282">"Ukufinyelela ukusebenzisa"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Nika amandla ukufinyelela kokusebenzisa"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Isikhathi sesikrini"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"Ukufinyelela kokusebenzisa kuvumela uhlelo lokusebenza ukuthi lulandelele ukuthi yiziphi ezinye izinhlelo zokusebenza ozisebenzisayo nokuthi kaningi kangakanani, kanye nenkampani yakho yenethiwekhi, izilungiselelo zolimi neminye imininingwane."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Imemori"</string>
    <string name="always_running" msgid="9012705720688200252">"Ihlala isebenza (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Kwesinye isikhathi iyasebenza (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Isebenza ngokungandile (<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">"Ukulungiselelwa kwebhethri"</string>
    <string name="high_power_filter_on" msgid="447849271630431531">"Akulungiselelwe"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Akulungiselelwe"</string>
    <string name="high_power_off" msgid="317000444619279018">"Ilungiselela ukusetshenziswa kwebhethri"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Ukulungiselelwa kwebhethri akutholakali"</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Uvumela i-app ihlale isebenza ngasemuva?"</string>
    <string name="high_power_prompt_body" msgid="6029266540782139941">"Ukuvumela i-<xliff:g id="APP_NAME">%1$s</xliff:g> ukuthi isebenze njalo ngemuva kungase kunciphise impilo yebhethri. \n\nUngashintsha lokhu kamuva kokuthi Amasethingi&gt; Ama-app."</string>
    <string name="battery_summary" msgid="2491764359695671207">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> ukusetshenziswa kusukela ekushajweni kugcwale kokugcina"</string>
    <string name="battery_summary_24hr" msgid="7656033283282656551">"Ukusetshenziswa okungu-<xliff:g id="PERCENTAGE">%1$s</xliff:g> kwamahora ama-24 adlule"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Akukho ukusetshenziswa kwebhethri kusukela ekushajeni kokugcina okudlule"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Yabelana ngombiko wesiphazamisi?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"Umqondisi wakho we-IT ucele umbiko wesiphazamisi ukukusiza ukuxazulula inkinga kule divayisi. Izinhlelo zokusebenza nedatha ingabiwa."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"Umlawuli wakho we-IT ucele umbiko wesiphazamisi ukusiza ukuxazulula inkinga yale divayisi. Izinhlelo zokusebenza nedatha kungabelwana, futhi idivayisi yakho ingahle yehle kancane."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"Lo mbiko wesiphazamiso wabiwe nomlawuli wakho we-IT. Xhumana nabo ngemininingwane."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Yabelana"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Yenqaba"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Akukho ukudluliswa kwedatha"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Shaja idivayisi exhunyiwe"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Ukudluliselwa kwefayela"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"I-PTP"</string>
    <string name="usb_use_uvc_webcam" msgid="6595429508472038732">"Ikhamera yekhompyutha"</string>
    <string name="usb_transcode_files" msgid="2441954752105119109">"Guqulela amavidyo ku-AVC"</string>
    <string name="usb_transcode_files_summary" msgid="307102635711961513">"Amavidiyo azodlala kuma-media player amaningi, kodwa ikhwalithi ingehliswa"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"Ukusebenzisa ifoni njengemodemu kwe-USB"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"I-MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"Sebenzisela i-USB i-"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Ukulungiselelwa kwe-USB okuzenzakalelayo"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Uma enye idivayisi ixhunyiwe futhi ifoni yakho ivulekile, lesi zilungiselelo zizosebenza. Kuxhumeke kuphela kumadivayisi athembekile."</string>
    <string name="usb_power_title" msgid="5602112548385798646">"Izinketho zamandla"</string>
    <string name="usb_file_transfer_title" msgid="2261577861371481478">"Izinketho zokudlulisa ifayela"</string>
    <string name="usb_pref" msgid="8521832005703261700">"I-USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"Okuncanyelwayo kwe-USB"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"I-USB ilawulwa nge-"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Idivayisi exhunyiwe"</string>
    <string name="usb_control_device" msgid="527916783743021577">"Le divayisi"</string>
    <string name="usb_switching" msgid="3654709188596609354">"Iyashintsha…"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"Ayikwazanga ukushintsha"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Ishaja le divayisi"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Ishaja idivayisi exhunyiwe"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Dlulisa ifayela"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"Ukusebenzisa ifoni njengemodemu kwe-USB"</string>
    <string name="usb_summary_photo_transfers" msgid="7331503733435780492">"I-PTP"</string>
    <string name="usb_summary_MIDI" msgid="2372443732675899571">"I-MIDI"</string>
    <string name="usb_summary_UVC" msgid="8733131110899174299">"Ikhamera yekhompyutha"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Ukudluliselwa kwefayela nokunikezwa kwamandla"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"Ukusebenzisa ifoni njengemodemu kwe-USB nokunikezwa kwamandla"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"I-PTP nokunikezwa kwamandla"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"I-MIDI nokunikezwa kwamandla"</string>
    <string name="usb_summary_UVC_power" msgid="226810354412154061">"Ikhamera yewebhu kanye namandla okuhlinzeka"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Ukuhlola kwangasemuva"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Sebenzisa umbhalo kusukela kusikrini"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Vumela uhlelo lokusebenza lokusiza ukuthi lufinyelele kokuqukethwe kwesikrini njengombhalo"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Sebenzisa isithombe-skrini"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Vumela uhlelo lokusebenza lokusiza ukuthi lufinyelele kusithombe sesikrini"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Banizisa isikrini"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Banizisa amaphethelo esikrini uma uhlelo lokusebenza lwesilekeleli lifinyelela kumbhalo kusukela kusikrini noma isithombe-skrini"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Izinhlelo zokusebenza zokusiza zingakusiza kususelwa kulwazi oluvela kusikrini osibukayo. Ezinye izinhlelo zokusebenza zisekela kokubili isiqalisi namasevisi wokufaka wezwi ukuze unikezwe usizo oluhlanganisiwe."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Ukusetshenziswa kwememori okumaphakathi"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Ukusetshenziswa kwememori okukhulu"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Ukusetshenziswa kwememori"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Ukusetshenziswa kohlelo lokusebenza"</string>
    <string name="memory_details" msgid="6133226869214421347">"Imininingwane"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"<xliff:g id="SIZE">%1$s</xliff:g> imemori emaphakathi esetshenziswe emahoreni angu-3 adlule"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"Ayikho imemori esetshenziswe emahoreni angu-3 adlule"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Hlunga ngokusetshenziswa okumaphakathi"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Hlunga ngokusetshenziswa okukhulu"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Ukusebenza"</string>
    <string name="total_memory" msgid="5244174393008910567">"Inani lememori"</string>
    <string name="average_used" msgid="690235917394070169">"Okumaphakathi okusetshenzisiwe (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Khululekile"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Imemori esetshenziswe yizinhlelo zokusebenza"</string>
    <string name="memory_usage_apps_summary" msgid="7168292864155527974">"{count,plural, =1{1 i-app esebenzise inkumbulo ekugcineni {time}}one{Ama-app angu-# asebenzise inkumbulo ekugcineni {time}}other{Ama-app angu-# asebenzise inkumbulo ekugcineni {time}}}"</string>
    <string name="force_enable_pss_profiling_title" msgid="2253816522775341523">"Nika ukwenza iphrofayela yokusetshenziswa kwenkumbulo amandla"</string>
    <string name="force_enable_pss_profiling_summary" msgid="7714294324548399136">"Ukusebenzisa iphrofayela yokusetshenziswa kwenkumbulo kudinga izinsiza zesistimu ezengeziwe."</string>
    <string name="pss_profiling_disabled" msgid="1967278421143514850">"Ukwenza iphrofayela yenkumbulo kukhutshaziwe"</string>
    <string name="running_frequency" msgid="7260225121706316639">"Imvamisa"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Ukusetshenziswa okukhulu"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Ayikho idatha esetshenzisiwe"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"Vumela ukufinyelela kokuthi Ungaphazamisi kwe-<xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"Uhlelo lokusebenza luzokwazi ukuvuleka/luvaleke Ungaphazamisi futhi lwenze izinguquko kuzilungiselelo eziphathelene."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Kufanele kuhlale kuvuliwe ngoba ukufinyelela kwesaziso kuvuliwe"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"Buyisa ukufinyelela kokuthi Ungaphazamisi ku-<xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"Yonke imithetho Ungaphazamisi edalwe yilolu hlelo lokusebenza kuzosuswa."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Ungalungiseleli"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Lungiselela"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Ingacwenga ibhethri lakho ngokushesha kakhulu. Uhlelo lokusebenza ngeke lusakhawulelwa kusukela ekusebenziseni ibhethri elingemuva."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Kunconyelwe impilo yebhethri"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Lutho"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Ukuvala ukufinyelela kokusebenzisa kulolu hlelo lokusebenza akuvikeli umlawuli wakho ukulandelela ukusetshenziswa kwedatha kuzinhlelo zakho zokusebenza kuphrofayela yakho yomsebenzi."</string>
    <string name="draw_overlay" msgid="7902083260500573027">"Bonisa phezu kwamanye ama-app"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Bonisa phezu kwamanye ama-app"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Vumela ukubonisa phezu kwamanye ama-app"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Vumela lolu hlelo lokusebenza ukuthi luboniswe ngaphezulu kwezinye izinhlelo zokusebenza ozisebenzisayo. Lolu hlelo lokusebenza luzokwazi ukubona uma uthepha noma ushintsha okuboniswa kusikrini."</string>
    <string name="media_routing_control_title" msgid="6402800638960066807">"Shintsha umphumela wemidiya"</string>
    <string name="allow_media_routing_control" msgid="4907036637509360616">"Vumela i-app ukushintsha okukhipha imidiya"</string>
    <string name="allow_media_routing_description" msgid="8343709701298051207">"Vumela le-app ukuthi ikhethe ukuthi iyiphi idivayisi exhunyiwe edlala umsindo noma ividiyo kwamanye ama-app. Uma kuvunyelwe, le-app ingafinyelela uhlu lwamadivayisi atholakalayo njengama-headphone nezipikha futhi lukhethe ukuthi iyiphi idivayisi yokukhishwayo esetshenziselwa ukusakaza noma ukusakaza umsindo noma ividiyo."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Ukufinyelela kuwo wonke amafayela"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Vumela ukufinyelela ukuze kuphathwe wonke amafayela"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Vumela lolu hlelo lokusebenza ukuthi lufunde, lulungise luphinde lususe wonke amafayela kule divayisi noma kwamanye amavolumu axhunyiwe esitoreji. Uma linikeziwe, uhlelo lokusebenza lungafinyelela kumafayela ngaphandle kokwazi kwakho okusobala."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Ingafinyelela kuwo wonke amafayela"</string>
    <string name="voice_activation_apps_title" msgid="7130045161611529825">"Ama-app okuvula i-Voice"</string>
    <string name="permit_voice_activation_apps" msgid="9152780172988949319">"Vumela ukwenza i-voice isebenze"</string>
    <string name="allow_voice_activation_apps_description" msgid="6369745626995060656">"Ukwenza kusebenze izwi kuvula ama-app agunyaziwe, i-hands-free, kusetshenziswa umyalo wezwi. Izinzwa eziguquguqukayo ezakhelwe ngaphakathi ziqinisekisa ukuthi idatha ihlala iyimfihlo kuwe kuphela.\n\n"<a href="">"Okwengeziwe mayelana nomuzwa oguqukayo ovikelekile"</a></string>
    <string name="full_screen_intent_title" msgid="747270185715224130">"Izaziso zesikrini esigcwele"</string>
    <string name="permit_full_screen_intent" msgid="9035367640019960861">"Vumela izaziso zesikrini esigcwele ukusuka kule app"</string>
    <string name="footer_description_full_screen_intent" msgid="7716518411349225528">"Vumela i-app ukuthi ibonise izaziso ezithatha isikrini esigcwele lapho idivayisi ikhiyiwe. Ama-app angasebenzisa lokhu ukuze agqamise ama-alamu, amakholi angenayo, noma ezinye izaziso eziphuthumayo."</string>
    <string name="media_management_apps_title" msgid="8222942355578724582">"Ama-app okuphatha imidiya"</string>
    <string name="media_management_apps_toggle_label" msgid="166724270857067456">"Vumela i-app ukuthi iphathe imidiya"</string>
    <string name="media_management_apps_description" msgid="8000565658455268524">"Uma ivunyelwe, le app ingaguqula noma isuse amafayela emidiya adalwe ngamanye ama-app ngaphandle kokukubuza. I-app kufanele ibe nemvume yokufinyelela amafayela nemidiya."</string>
    <string name="keywords_media_management_apps" msgid="7499959607583088690">"Imidiya, Ifayela, Ukuphathwa, Umphathi, Phatha, Hlela, Isihleli, i-App, Ukusebenza, Uhlelo"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"isevisi yomsizi we-vr wangempela okubonakalayo kwesitiriyo somlaleli"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Bonisa phezu kwamanye ama-app"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Izinhlelo zokusebenza ezinemvume"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Kuvumelekile"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Akuvumelekile"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"faka izinhlelo zokusebenza zemithombo engaziwa"</string>
    <string name="write_settings" msgid="6864794401614425894">"Shintsha amasethingi esistimu"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"bhala izilungiselelo zokushintsha isistimu"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Ingafaka ezinye izinhlelo zokusebenza"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Ingashintsha izilungiselelo zesistimu"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Ingashintsha izilungiselelo zesistimu"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Shintsha amasethingi esistimu"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Vumela izilungiselelo zesistimu yokushintsha"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Le mvume ivumela uhlelo lokusebenza ukushintsha izilungiselelo zesistimu."</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Vumela kusukela kulo mthombo"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Shinthsa kabili ingalo ukuze uthole ikhamera"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Vula uhlelo lokusebenza lekhamera ngokushintsha ingalo yakho kabili"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Usayizi wokubonisa"</string>
    <string name="screen_zoom_short_summary" msgid="756254364808639194">"Yenza konke kube kukhulu noma kube kuncane"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"bonisa ukuminyana, ukusondezwa kwesikrini, isikali, ukufaka kusikali"</string>
    <string name="screen_zoom_preview_title" msgid="5288355628444562735">"Hlola kuqala"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Yenza kube kuncane"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Yenza kube kukhulu"</string>
    <string name="disconnected" msgid="3469373726996129247">"Akuxhunyiwe"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Akuxhunyiwe"</string>
    <string name="apps_summary" msgid="4007416751775414252">"<xliff:g id="COUNT">%1$d</xliff:g> izinhlelo zokusebenza ezifakiwe"</string>
    <string name="storage_summary" msgid="5903562203143572768">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> okustshenzisiwe - <xliff:g id="FREE_SPACE">%2$s</xliff:g> mahhala"</string>
    <string name="display_dashboard_summary" msgid="1599453894989339454">"Itimu emnyama, usayizi wefonti, ukukhanya"</string>
    <string name="memory_summary" msgid="8221954450951651735">"Okumaphakathi okungu-<xliff:g id="USED_MEMORY">%1$s</xliff:g> kokungu-<xliff:g id="TOTAL_MEMORY">%2$s</xliff:g> imemori esetshenzisiwe"</string>
    <string name="users_summary" msgid="8473589474976307510">"Ungene ngemvume njengo-<xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Ibuyekezelwe ku-Android engu-<xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"Isibuyekezo siyatholakala"</string>
    <string name="disabled_by_policy_title" msgid="6852347040813204503">"Ivinjwe yinqubomgomo yomsebenzi"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Ayikwazi ukushintsha ivolumu"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="400089720689494562">"Ayikwazi ukwenza amakholi"</string>
    <string name="disabled_by_policy_title_sms" msgid="8951840850778406831">"Ayikwazi ukuthumela imiyalezo ye-SMS"</string>
    <string name="disabled_by_policy_title_camera" msgid="6616508876399613773">"Ayikwazi ukusebenzisa ikhamera"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6085100101044105811">"Ayikwazi ukuthatha izithombe-skrini"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Ayikwazi ukuvula lolu hlelo lokusebenza"</string>
    <string name="disabled_by_policy_title_financed_device" msgid="2328740314082888228">"Kuvinjwe umhlinzeki wakho wekhredithi"</string>
    <string name="disabled_by_policy_title_biometric_parental_consent" msgid="2463673997797134678">"Umzali uyadingeka"</string>
    <string name="disabled_by_policy_content_biometric_parental_consent" msgid="7124116806784305206">"Nika ifoni umzali wakho ukuze uqale ukusetha lokhu"</string>
    <string name="disabled_by_policy_parental_consent" msgid="9166060049019018978">"Nika umzali wakho ifoni ukuze avumele leli sethingi ukuthi lishintshwe."</string>
    <string name="default_admin_support_msg" msgid="8816296554831532033">"Ukuze uthole ulwazi olwengeziwe, xhumana nomphathi wakho we-IT."</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Imininingwane engaphezulu"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"Umqondisi wakho angakwazi ukwengamela futhi aphathe izinhlelo zokusebenza nedatha ephathelene nephrofayela yakho yomsebenzi kufaka phakathi izilungiselelo, izimvume, ukufinyelela kwezinkampani, umsebenzi wenethiwekhi kanye nolwazi lwedivayisi yakho."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"Umqondisi wakho angakwazi ukwengamela futhi aphathe izinhlelo zokusebenza nedatha ephathelene nalo msebenzisi, kufaka phakathi izilungiselelo, izimvume, ukufinyelela kwezinkampani, umsebenzi wenethiwekhi kanye nolwazi lwendawo ledivayisi yakho."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"Umqondisi wakho angakwazi ukwengamela nokuphatha izinhlelo zokusebenza nedatha ephathelene naele divayisi, kufaka phakathi izimvume zezilungiselelo, ukufinyelela kwebhizinisi, umsebenzi wenethiwekhi nolwazi lwendawo yedivayisi yakho."</string>
    <string name="admin_financed_message" msgid="1156197630834947884">"Umlawuli wedivayisi yakho kungenzeka akwazi ukufinyelela kudatha ehambisana nale divayisi, aphathe ama-app, aphinde ashintshe amasethingi alawa madivayisi."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Vala"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Vula"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Umbukiso"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Fihla"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"I-hotspot iyasebenza"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Imodi yendiza ivuliwe"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Amanethiwekhi awatholakali"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"Ukungaphazamisi kuvuliwe"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Ifoni ithulisiwe"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"Ngokuhlukile"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Isilondolozi sebhethri sivuliwe"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Izici zikhawulelwe"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Idatha yeselula ivaliwe"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"I-inthanethi itholakala kuphela nge-Wi-Fi"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Iseva yedatha"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Izici zikhawulelwe"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Iphrofayela yomsebenzi ivaliwe"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Okwezinhlelo zokusebenza nezaziso"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Vula umsindo"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Ukukhala kuthulisiwe"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Okwamakholi nezaziso"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Ukudlidliza kuphela"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Kwamakholi nezaziso"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Bona ishejuli yokukhanya kwasebusuku"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Ngokuzenzakalela yenza i-tint yesikrini njalo ngobusuku"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"Ukukhanya kwasebusuku kuvuliwe"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Isikrini sifiphaliswe nge-amber"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"I-grayscale"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Bonisa kuphela ngombala ompunga"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Goqa"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Ithempelesha yombala opholile"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Sebenzisa imibala yesibonisi esipholile"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Ukuze usebenzise ukushintshwa kombala, vala isikrini"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Inzwa ye-Laser yekhamera"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Izibuyekezo zesistimu ezenzakalelayo"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Faka izibuyekezo uma idivayisi iqalisa kabusha"</string>
    <string name="usage" msgid="287782903846013936">"Ukusetshenziswa"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Ukusetshenziswa kwedatha yeselula"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Ukusetshenziswa kwedatha yohlelo lokusebenza"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"Ukusetshenziswa kwedatha ye-Wi-Fi"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Ukusetshenziswa kwedatha engeyona eyenkampani yenethiwekhi"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Ukusetshenziswa kwedatha kwe-ethernet"</string>
    <string name="wifi" msgid="2932584495223243842">"Wi-Fi"</string>
    <string name="ethernet" msgid="4665162609974492983">"I-Ethernet"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"<xliff:g id="AMOUNT">^1</xliff:g> idatha yeselula"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"<xliff:g id="AMOUNT">^1</xliff:g> idatha ye-Wi-Fi"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"<xliff:g id="AMOUNT">^1</xliff:g> idatha ye-ethernet"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Isexwayiso sedatha nomkhawulo"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Umjikelezo wokusetshenziswa kwedatha yeselula"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"<xliff:g id="ID_1">^1</xliff:g> isexwayiso sedatha"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"<xliff:g id="ID_1">^1</xliff:g> umkhawulo wedatha"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"<xliff:g id="ID_1">^1</xliff:g> isexwayiso sedatha / <xliff:g id="ID_2">^2</xliff:g> umkhawulo wedatha"</string>
    <string name="non_carrier_data_usage_warning" msgid="4707184871368847697">"Ayifaki phakathi idatha esetshenziswe izinkampani zenethiwekhi"</string>
    <string name="data_used_template" msgid="8229342096562327646">"<xliff:g id="ID_1">%1$s</xliff:g> okusetshenzisiwe"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Setha isexwayiso sedatha"</string>
    <string name="data_warning" msgid="2925054658166062884">"Isexwayiso sedatha"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"Isexwayiso sedatha nomkhawulo wedatha kulinganiselwa ngedivayisi yakho. Lokhu kungahluka kusukela kudatha yenkampani yenethiwekhi."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Setha umkhawulo wedatha"</string>
    <string name="data_limit" msgid="8731731657513652363">"Umkhawulo wedatha"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"<xliff:g id="ID_1">%1$s</xliff:g> esetsenzisiwe ngomhla ka-<xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="configure" msgid="1499586749829665889">"Lungiselela"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Ezinye izinhlelo zokusebenza ezifakwe ekusetshenzisweni"</string>
    <string name="data_saver_unrestricted_summary" msgid="7343571401172437542">"{count,plural, =1{1 i-app ivunyelwe ukuze kusetshenziswe idatha engakhawulelwe uma Iseva Yedatha ivuliwe}one{# ama-app avunyelwe ukuze kusetshenziswe idatha engakhawulelwe uma Iseva Yedatha ivuliwe}other{# ama-app avunyelwe ukuze kusetshenziswe idatha engakhawulelwe uma Iseva Yedatha ivuliwe}}"</string>
    <string name="data_usage_title" msgid="4039024073687469094">"Idatha eyinhloko"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"Idatha ye-Wi-Fi"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"<xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g> esetshenzisiwe"</string>
    <string name="data_overusage" msgid="3680477320458707259">"<xliff:g id="ID_1">^1</xliff:g> ngaphezulu"</string>
    <string name="data_remaining" msgid="6316251496381922837">"<xliff:g id="ID_1">^1</xliff:g> osele"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Igrafu ebonisa ukusetshenziswa kwedatha phakathi kuka-<xliff:g id="START_DATE">%1$s</xliff:g> no-<xliff:g id="END_DATE">%2$s</xliff:g>."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"Ayikho idatha kuleli banga ledethi"</string>
    <string name="billing_cycle_days_left" msgid="174337287346866400">"{count,plural, =1{usuku olusele olungu-#}one{izinsuku ezisele ezingu-#}other{izinsuku ezisele ezingu-#}}"</string>
    <string name="billing_cycle_none_left" msgid="1694844019159277504">"Asikho isikhathi esisele"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Kusele ngaphansi kosuku olungu-1"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"Kubuyekezwe i-<xliff:g id="ID_1">^1</xliff:g> nge-<xliff:g id="ID_2">^2</xliff:g> edlule"</string>
    <string name="no_carrier_update_text" msgid="5432798085593055966">"Kubuyekezwe nge-<xliff:g id="ID_1">^2</xliff:g> edlule"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Kubuyekezwe i-<xliff:g id="ID_1">^1</xliff:g> khona manje"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Kusandwa ukubuyekezwa"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Buka imininingwane"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Iseva yedatha"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Idatha engakhawulelwe"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Idatha yangemuva ivaliwe"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"Vuliwe"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Valiwe"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Sebenzisa iseva yedatha"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Ukusetshenziswa kwedatha okungakhawulelwe"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Vumela ukufinyelela kudatha okungakhawulelwe uma Iseva Yedatha ivuliwe"</string>
    <string name="home_app" msgid="6056850504746902747">"Uhlelo lokusebenza lwasekhaya"</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Engeza ezinye izigxivizo zeminwe"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Vula ngomunwe ohlukile"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"Vuliwe"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Izovuleka ku-<xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Valiwe"</string>
    <string name="app_battery_usage_title" msgid="346558380609793334">"Ukusetshenziswa kwebhethri yi-app"</string>
    <string name="app_battery_usage_summary" msgid="6349965904306339539">"Setha ukusetshenziswa kwebhethri kuma-app"</string>
    <string name="battery_tips_card_action_button" msgid="4897793527424711648">"Buka Amasethingi"</string>
    <string name="battery_tips_card_action_button_check" msgid="1535140204105479318">"Maka"</string>
    <string name="battery_tips_card_dismiss_button" msgid="1885756985544936618">"Ngiyezwa"</string>
    <string name="battery_tips_card_feedback_info" msgid="767117835675157298">"Ingabe lo myalezo uwusizo?"</string>
    <string name="battery_hints_warning_icon_a11y" msgid="5312542323401447620">"Isithonjana samathiphu ezixwayiso zebhethri"</string>
    <string name="battery_tips_settings_summary_brightness" msgid="546145032616077783">"Vula ukukhanya okuguqukayo ukuze unwebe impilo yebhethri"</string>
    <string name="battery_tips_settings_summary_screen_timeout" msgid="556801426050962077">"Nciphisa ukuphelelwa isikhathi kwesikrini ukuze unwebe impilo yebhethri"</string>
    <string name="battery_tips_apps_summary_always_high" msgid="6334519477067044920">"I-<xliff:g id="APP_LABEL">%1$s</xliff:g> isebenzise ibhethri eyengeziwe"</string>
    <string name="battery_tips_apps_summary_higher_than_usual" msgid="95676961671544628">"I-<xliff:g id="APP_LABEL">%1$s</xliff:g> isebenzise ibhethri eyengeziwe kunokujwayelekile"</string>
    <string name="battery_tips_apps_summary_always_high_in_background" msgid="2953858181710181126">"I-<xliff:g id="APP_LABEL">%1$s</xliff:g> isebenzise ibhethri eyengeziwe kuyilapho ingemuva"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_background" msgid="1585002072567422199">"I-<xliff:g id="APP_LABEL">%1$s</xliff:g> isebenzise ibhethri eyengeziwe kunokujwayelekile ingemuva"</string>
    <string name="battery_tips_apps_summary_always_high_in_foreground" msgid="1910991243576404700">"I-<xliff:g id="APP_LABEL">%1$s</xliff:g> isebenzise ibhethri eyengeziwe kuyilapho ingaphambili"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_foreground" msgid="7937337570425168210">"I-<xliff:g id="APP_LABEL">%1$s</xliff:g> isebenzise ibhethri eyengeziwe kunokujwayelekile ngaphambili"</string>
    <string name="battery_usage_anomaly_content_description" msgid="3199380151630770476">"Ukusetshenziswa kwebhethri okudidayo"</string>
    <string name="battery_app_item_hint" msgid="4850929961461039110">"Ukusetshenziswa kwebhethri okuphezulu"</string>
    <string name="battery_app_item_hint_in_bg" msgid="596240821466388336">"Ukusetshenziswa kwebhethri ngemuva"</string>
    <string name="battery_app_item_hint_in_fg" msgid="5091860632260799910">"Ukusetshenziswa kwebhethri ngaphambili"</string>
    <string name="filter_battery_unrestricted_title" msgid="821027369424198223">"Akunamkhawulo"</string>
    <string name="filter_battery_optimized_title" msgid="8236647176487754796">"Kulungisiwe"</string>
    <string name="filter_battery_restricted_title" msgid="5886859505802563232">"Kuvinjelwe"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Isihloli sokupela esizenzakalelayo"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Khetha isihloli sokupela"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Sebenzisa isihloli sokupela"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Abangakhethiwe"</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">"ukhiye"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"iqembu"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(isifinyezo)"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"inguqulo yomphakathi"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"ukubaluleka"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"incazelo"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"ingabonisa ibheji"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"inhloso"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"sula inhloso"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"inhloso yesikrini esigcwele"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"izenzo"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"isihloko"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"kokufaka kwerimothiremote inputs"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"ukubuka kwangezifiso"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"okungeziwe"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"isithonjana"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"usayizi wephasela"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"isaziso sazisiwe"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"isiteshi"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Into yokulinganisa ilahlekile."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"Into yokulinganisa ayiqukethe lo khiye."</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Ukusikwa kwesiboniso"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"bonisa ukusika, inotshi"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Idivayisi ezenzakalelayo"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Yehlulekile ukusebenzisa imbondela"</string>
    <string name="special_access" msgid="1767980727423395147">"Ukufinyelela kwi-app okukhethekile"</string>
    <string name="special_access_more" msgid="132919514147475846">"Bona okwengeziwe"</string>
    <string name="long_background_tasks_label" msgid="3169590134850226687">"Imisebenzi yangemuva emide"</string>
    <string name="long_background_tasks_switch_title" msgid="2491623894899492543">"Vumela imisebenzi yangemuva esebenza isikhathi eside"</string>
    <string name="long_background_tasks_title" msgid="3272230637974707490">"Imisebenzi yangemuva emide"</string>
    <string name="long_background_tasks_footer_title" msgid="9117342254914743097">"Vumela le-app ukuthi iqalise imisebenzi engemuva emide. Lokhu kuvumela i-app ukuthi iqhube imisebenzi engathatha isikhathi eside kunemizuzu embalwa ukuqeda, njengokudawunilodwa nokulayishwayo. \n\nUma le mvume yenqatshwa, isistimu izokhawulela ukuthi i-app ingakwazi ukwenza imisebenzi enjalo ngemuva isikhathi esingakanani."</string>
    <string name="keywords_long_background_tasks" msgid="5788956269136054574">"imisebenzi emide, ukudluliswa kwedatha, imisebenzi yangemuva"</string>
    <string name="run_backup_tasks_title" msgid="8572480651659803275">"Yenza imisebenzi yokwenza isipele ngemuva"</string>
    <string name="run_backup_tasks_switch_title" msgid="4740767959730361777">"Vumela i-app ukuqalisa ngemuva imisebenzi ehambisana nokwenza isipele"</string>
    <string name="run_backup_tasks_footer_title" msgid="1766222193265152388">"Ibonisa ukuthi le app inesimo sokusetshenziswa esikhulu lapho idinga ukwenziwa isipele khona noma ivumelanise okuqukethwe. Ukunikeza le mvume kuvumela i-app ukuthi iqalise ngemuva ngesikhathi eside kancane ukuze kuqedelelwe umsebenzi ohambisana nokwenza isipele. \n\nUma le mvume inqatshelwa, isistimu ngeke inikeze ukukhishwa okukhethekile kule app ukuze kuqedelelwe umsebenzi ohambisana nokwenza isipele ngemuva."</string>
    <string name="keywords_run_backup_tasks" msgid="632219905465766211">"imisebenzi eyisipele, imisebenzi eyisipele"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Setha kabusha ukukhawulela kokulinganisela kwe-ShortcutManager"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"Ukukhawulela kokulinganisela kwe-ShortcutManager kusethwe kabusha"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Lawula ulwazi ekukhiyeni isikrini"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Bonisa noma fihla okuqukethwe kwesaziso"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Amathiphu nosekelo"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Ububanzi obuncane"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Azikho izinhlelo zokusebenza ezicele ukufinyelela kwe-Premium SMS"</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"I-Premium SMS ingakwenzela izindleko zemali futhi izongeza kumabhili enkampani yenethiwekhi. Uma unika amandla imvume yohlelo lokusebenza, uzokwazi ukuthumela i-premium SMS usebenzisa lolo hlelo lokusebenza."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Ukufinyelela ku-Premium SMS"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Valiwe"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Ixhumeke ku-<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Ixhumeke kumadivayisi amaningi"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Imodi yedemo ye-UI yesistimu"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Itimu emnyama"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Kukhutshaziwe okwesikhashana ngenxa Yesilondolozi Sebhethri"</string>
    <string name="ambient_camera_summary_battery_saver_on" msgid="1787784892047029560">"Kukhutshaziwe okwesikhashana ngenxa Yesilondolozi Sebhethri"</string>
    <string name="ambient_camera_battery_saver_off" msgid="689825730569761613">"Vala isilondolozi sebhethri"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Kuvulwe okwesikhashana ngenxa yesilondolozi sebhethri"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Itimu emnyama"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Isiza ukunwebisa impilo yebhethri"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Othayela bonjiniyela bezilungiselelo ezisheshayo"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Khubaza ukugunyazwa isikhathi sokuvala se-adb"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Khubaza ukuhoxiswa okuzenzakalelayo kokugunyazwa kwe-adb kwamasistimu angazange aphinde axhume phakathi kokuzenzekelayo (izinsuku esingu-7) noma alungiselelwe ngumsebenzisi (usuku olungu-1 ubuncane) ngenani lesikhathi."</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Izinzwa zivaliwe"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Amasethingi ephrofayela yomsebenzi"</string>
    <string name="managed_profile_contact_search_title" msgid="6562061740814513737">"Sesha oxhumana nabo bohla lwemibhalo lomsebenzi kuma-app womuntu siqu"</string>
    <string name="managed_profile_contact_search_summary" msgid="4974727886709219105">"Ukusesha kwakho namakholi angenayo angabonakala kumphathi wakho we-IT"</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Ikhalenda yayo yonke iphrofayela"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Bonisa imicimbi esebenzayo kukhalenda yakho yomuntu siqu"</string>
    <string name="managed_profile_settings_footer" msgid="996500759305118103">"Uma izinhlelo ama-app omsebenzi evaliwe, ayamiswa futhi awakwazi ukufinyelelwa noma akuthumelele izaziso"</string>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Phatha isitoreji"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"Ukuze kusizwe kukhululwe isikhala sesitoreji, isiphathi sesitoreji sisusa izithombe ezenziwe isipele namavidiyo kusukela kudivayisi yakho."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Susa izithombe namavidiyo"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Isiphathi sesitoreji"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Sebenzisa isiphathi sesitoreji"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Ukuthinta"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Vula ngokushesha ikhamera"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Ukuze uvule ngokushesha ikhamera yakho, cindezela inkinobho yamandla kabili. Isebenza kusukela kunoma isiphi isikrini."</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Phenya ikhamera yesithombe ozishuthe sona"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="system_navigation_title" msgid="4890381153527184636">"Inqubo yokuzulazula"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Ukuzula kwezinkinobho ezingu-2"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"Ukuze ushintshe izinhlelo zokusebenza, swayiphela phezulu kunkinobho yasekhaya. Ukuze ubone izinhlelo zokusebenza, swayiphela phezulu futhi. Ukuze ubuyele emuva, thepha inkinobho ethi emuva."</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Ukuphepha nesimo esiphuthumayo"</string>
    <string name="emergency_dashboard_summary" msgid="401033951074039302">"I-SOS Yezimo Eziphuthumayo, ulwazi lwezokwelapha, izexwayiso"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Ukuzula kokwenziwayo"</string>
    <string name="edge_to_edge_navigation_summary" msgid="818109176611921504">"Ukuze uye ekhaya, swayiphela phezulu kusuka phansi kwesikrini. Ukuze ushintshe izinhlelo zokusebenza, swayiphela phezulu kusukela ngaphansi, ubambe, bese uyadedela. Ukuze ubuyele emuva, swayipha kusukela kunqenqema langakwesokunxele noma kwesokudla."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"Ukuzula kwezinkinobho ezingu-3"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Buyela emuva, Ekhaya, uphinde ushintshe izinhlelo zokusebenza ngezinkinobho ngaphansi kwesikrini sakho."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"ukuzula kwesistimu, 2-inkinobho yokuzula, 3-inkinobho yokuzula, ukuzula kokuthinta, swayipha"</string>
    <string name="assistant_gesture_category_title" msgid="2478251256585807920">"Umsizi odijithali"</string>
    <string name="assistant_corner_gesture_title" msgid="1895061522687002106">"Swayipha ukuze uncenge umsizi"</string>
    <string name="assistant_corner_gesture_summary" msgid="5012534700233017955">"Swayiphela phezulu usuka ekhoneni elingezansi ukuze uncenge i-app yakho yomsizi wedijithali"</string>
    <string name="assistant_long_press_home_gesture_title" msgid="4865972278738178753">"Bamba Ikhaya ngokuqondene ne-Assistant"</string>
    <string name="assistant_long_press_home_gesture_summary" msgid="592882226105081447">"Cindezela futhi ubambe inkinobho ethi Ikhaya ukuze uncenge i-app yomsizi edijithali."</string>
    <string name="low_label" msgid="6525629096999711220">"Phansi"</string>
    <string name="high_label" msgid="357503396626018487">"Phezulu"</string>
    <string name="left_edge" msgid="1513576842959071849">"Umkhawulo ongakwesokunxele"</string>
    <string name="right_edge" msgid="1505309103265829121">"Umkhawulo ongakwesokudla"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"Ukuzwela okuphezulu kungagxubuzana nanoma yikuphi ukuthinta kohlelo lokusebenza emiphethweni yesikrini."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Ukuzwela kwasemuva"</string>
    <string name="gesture_settings_activity_title" msgid="2025828425762595733">"Ukuzwela Kokubhekabheka Ngokuthinta"</string>
    <string name="button_navigation_settings_activity_title" msgid="7335636045504461813">"Ukubhekabheka ngenkinobho"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"ukuzula kokuthinta, ukuzwela kwasemuva, ukuthinta kwasemuva"</string>
    <string name="keywords_button_navigation_settings" msgid="7888812253110553920">"ukuzula, inkinobho yekhaya"</string>
    <string name="one_handed_title" msgid="2584414010282746195">"Imodi yesandla esisodwa"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Sebenzisa imodi yesandla esisodwa"</string>
    <string name="one_handed_mode_shortcut_title" msgid="1847871530184067369">"Isinqamuleli semodi yesandla esisodwa"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"ukufinyeleleka"</string>
    <string name="one_handed_mode_swipe_down_category" msgid="110178629274462484">"Swayiphela phansi ukuze"</string>
    <string name="one_handed_mode_use_shortcut_category" msgid="1414714099339147711">"Sebenzisa isinqamuleli esiya kokuthi"</string>
    <string name="one_handed_mode_intro_text" msgid="7921988617828924342">"Donsela phansi ingxenye engaphezulu yesikrini sakho ukuze kube lula ukusifinyelela ngesandla esisodwa"</string>
    <string name="one_handed_mode_footer_text" msgid="6336209800330679840">" "<b>"Indlela yokusebenzisa imodi yesandla esisodwa"</b>\n" • Qiniseka ukuthi ukuzulazula ngokuthinta kukhethiwe kumasethingi okuzulazula wesistimu\n • Swayiphela phansi eduze konqenqema olungezansi kwesikrini"</string>
    <string name="one_handed_action_pull_down_screen_title" msgid="9187194533815438150">"Donsa isikrini ukuze ufinyelele"</string>
    <string name="one_handed_action_pull_down_screen_summary" msgid="7582432473450036628">"Ingaphezulu lesikrini lizohamba lifinyelele isithupha sakho."</string>
    <string name="one_handed_action_show_notification_title" msgid="8789305491485437130">"Bonisa izaziso"</string>
    <string name="one_handed_action_show_notification_summary" msgid="8281689861222000436">"Izaziso namasethingi azovela."</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Ukuze uhlole isikhathi, izaziso, nolunye ulwazi, thepha kabili isikrini sakho."</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Vusa isiboniso"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Ukuze uhlole isikhathi, izaziso, nolunye ulwazi, thepha isikrini sakho."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"Isimo esiphuthumayo se-SOS"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7421353963329899514">"Sebenzisa i-SOS Yezimo Eziphuthumayo"</string>
    <string name="emergency_gesture_screen_summary" msgid="6640521030845132507">"Cindezela inkinobho Yamandla ngokushesha izikhathi ezi-5 noma ngaphezulu ukuqala izenzo ezingezansi"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Dlala i-alamu yokubala wehla"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="6573377104470235173">"Dlala umsindo ophezulu uma i-SOS Yezimo Eziphuthumayo iqalisa"</string>
    <string name="emergency_gesture_category_call_for_help_title" msgid="1680040129478289510">"Yazisa ukuze uthole usizo"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Shaya ikholi ukuze uthole usizo"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Inombolo yokushayela usizo"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Thepha ukuze ushintshe"</string>
    <string name="emergency_gesture_number_override_notes" msgid="233018570696200402">"Uma ufaka inombolo engeyona ephuthumayo:\n • Idivayisi yakho kufanele ivulwe ukuze ukwazi ukusebenzisa i-SOS Yezimo Eziphuthumayo\n • Ikholi yakho ingase ingaphendulwa"</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Swayipha izigxivizo zeminwe ukuze uthole izaziso"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Swayipha izigxivizo zeminwe"</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Bona izaziso ngokushesha"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"Kuvuliwe"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Kuvaliwe"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"I-Bootloader isivele ivuliwe"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Xhumeka ku-inthanethi noma uxhumane nenkampani yakho yenethiwekhi"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Ayitholakali kumadivayisi akhiywe inkampani yenethiwekhi"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Sicela ucalise kabusha idivayisi ukuze unike amandla isici lokuvikela idivaiyisi."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"<xliff:g id="SIZE">%1$s</xliff:g> isikhala senziwe satholakala\n\nKugcinwe ukusetshenziswa ngomhla ka-<xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="6654581786741216382">"Izinhlelo zokusebenza ezisheshayo"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Vula izixhumanisi kuzinhlelo zokusebenza, nanoma zingafakiwe"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Izinhlelo zokusebenza ezisheshayo"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Okuncamelayo kwezinhlelo zokusebenza ezisheshayo"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Izinhlelo zokusebenza ezifakiwe"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Isitoreji sakho manje siphethwe umphathi wesitoreji"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Ama-akhawunti e-<xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Vumelanisa ngokuzenzekelayo idatha yohlelo lokusebenza"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Vumela izinhlelo zokusebenza ziqalise kabusha idatha ngokuzenzakalelayo"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Ukuvumelanisa kwe-akhawunti"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Ukuvumelanisa kuvulelwe okungu-<xliff:g id="ID_1">%1$d</xliff:g> kuzinto ezingu-<xliff:g id="ID_2">%2$d</xliff:g>"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Ukuvumelanisa kuvulelwe zonke izinto"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Ukuvumelanisa kuvalelwe zonke izinto"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Ulwazi lwedivayisi oluphethwe"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Ushintsho nezilungiselelo eziphethwe inhlangano yakho"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Ushintsho nezilungiselelo eziphethwe yi-<xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"Ukuze kunikezwe ukufinyelela kudatha yakho yomsebenzi, inhlangano yakho ingashintsha izilungiselelo iphinde ifake isofthiwe kudivayisi yakho.\n\nUkuze uthole eminye imininingwane, xhumana nomlawuli wenhlangano yakho."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Izinhlolo zolwazi ezingabonwa inhlangano yakho"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Ushintsho olwenziwe umlawuli wenhlangano yakho"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Ukufinyelela kwakho kule divayisi"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Idatha esondelene ne-akhawunti yakho yomsebenzi, efana ne-imeyili nekhalenda"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Uhlu lwezinhlelo zokusebenza ezikudivayisi yakho"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Inani lesikhathi nedatha echithwe kuhlelo lokusebenza ngalinye"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Ilogo yethrafikhi yenethiwekhi yakamuva kakhulu"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Umbiko wakamuva kakhulu wesiphazamisi"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Ilogi lokuvikela lakamuva kakhulu"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Lutho"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Izinhlelo zokusebenza ezifakiwe"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"Inombolo yezinhlelo zokusebenza iyalinganiselwa. Ingahle ingabandakanyi izinhlelo zokusebenza ezingaphandle kwe-Google Play Isitolo."</string>
    <string name="enterprise_privacy_number_packages_lower_bound" msgid="5317634640873658149">"{count,plural, =1{Ubuncane obu-# be-app}one{Ubuncane obungu-# bama-app}other{Ubuncane obungu-# bama-app}}"</string>
    <string name="enterprise_privacy_location_access" msgid="8023838718108456971">"Izimvume zendawo"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Izimvume zemakrofoni"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Izimvume zekhamera"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Ama-app azenzekelayo"</string>
    <string name="enterprise_privacy_number_packages" msgid="5294444005035188274">"{count,plural, =1{i-app e-#}one{ama-app angu-#}other{ama-app angu-#}}"</string>
    <string name="enterprise_privacy_input_method" msgid="3278314982700662246">"Ikhibhodi ezenzakalelayo"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Sethela ku-<xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"I-VPN ehlala ivuliwe ivuliwe"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"I-VPN ehlala ivuliwe ivuliwe kuphrofayela yakho yomuntu siqu"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"I-VPN ehlala ivuliwe ivuliwe kuphrofayela yakho yomsebenzi"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Ummeleli we-Global HTTP usethiwe"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Izifakazeli ezithenjwayo"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Ukuqinisekisa okwethembekile kuphrofayela yomuntu siqu"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Ukuqinisekisa okwethembekile kuphrofayela yakho yomsebenzi"</string>
    <string name="enterprise_privacy_number_ca_certs" msgid="4540897122831942658">"{count,plural, =1{Ubuncane obu-# besitifiketi se-CA}one{Ubuncane obungu-# bezitifiketi ze-CA}other{Ubuncane obungu-# bezitifiketi ze-CA}}"</string>
    <string name="enterprise_privacy_lock_device" msgid="464054894363899866">"Umlawuli angakhiya idivayisi aphinde asethe kabusha iphasiwedi"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"Umlawuli angasusa yonke idatha yedivayisi"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Imizamo yephasiwedi ehlulekile ngaphambi kokususa yonke idatha yedivayisi"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Imizamo ehlulekile yephasiwedi ngaphambi kokususa idatha yephrofayela yomsebenzi"</string>
    <string name="enterprise_privacy_number_failed_password_wipe" msgid="2695842143305867642">"{count,plural, =1{umzamo o-#}one{imizamo engu-#}other{imizamo engu-#}}"</string>
    <string name="do_disclosure_generic" msgid="3067459392402324538">"Le divayisi iphethwe inhlangano yakho."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"Le divayisi iphethwe yi-<xliff:g id="ORGANIZATION_NAME">%s</xliff:g>."</string>
    <string name="do_disclosure_learn_more_separator" msgid="5714364437437041671">" "</string>
    <string name="learn_more" msgid="3534519107947510952">"Funda kabanzi"</string>
    <string name="blocked_by_restricted_settings_title" msgid="7334715011474037399">"Amasethingi akhawulelwe"</string>
    <string name="toast_allows_restricted_settings_successfully" msgid="1219116121291466102">"Amasethingi akhawulelwe avunyelwe mayelana ne-<xliff:g id="APP_NAME">%s</xliff:g>"</string>
    <string name="blocked_by_restricted_settings_content" msgid="3628660029601161080">"Ngokuphepha kwakho, leli sethingi okwamanje alitholakali."</string>
    <string name="financed_privacy_settings" msgid="2575114436197204145">"Ulwazi lwedivayisi oluhlinzekwe ngemali"</string>
    <string name="financed_privacy_intro" msgid="7836497475568741579">"Umhlinzeki wakho wekhredithi angashintsha amasethingi futhi afake isofthiwe kule divayisi phakathi nokusetha.\n\nUma uphuthelwa yinkokhelo, umhlinzeki wakho wekhredithi angakhiya idivayisi yakho futhi ashintshe amasethingi wedivayisi.\n\nUkuze ufunde kabanzi, xhumana nomhlinzeki wakho wekhredithi."</string>
    <string name="financed_privacy_restrictions_category" msgid="2472659467919651602">"Uma idivayisi yakho ixhaswe ngezimali, awukwazi:"</string>
    <string name="financed_privacy_install_apps" msgid="7381718005710210851">"Faka ama-app avela ngaphandle kwe-Google Play"</string>
    <string name="financed_privacy_safe_mode" msgid="5362149445732602578">"Qalisa idivayisi yakho kumodi ephephile"</string>
    <string name="financed_privacy_multi_users" msgid="1727194928477613081">"Engeza abasebenzisi abaning kudivayisi yakho"</string>
    <string name="financed_privacy_config_date_time" msgid="8567370445374984365">"Shintsha ilanga, isikhathi, nezoni yesikhathi"</string>
    <string name="financed_privacy_developer_options" msgid="7602001474669831672">"Sebenzisa okungakhwethwa konjiniyela"</string>
    <string name="financed_privacy_credit_provider_capabilities_category" msgid="8737902277892987998">"Umhlinzeki wakho wekhredithi anga-:"</string>
    <string name="financed_privacy_IMEI" msgid="1852413860963824799">"Finyelela inombolo yakho ye-IMEI"</string>
    <string name="financed_privacy_factory_reset" msgid="5505016667590160732">"Setha kabusha njengasekuqaleni idivayisi yakho uma kukhona okungahambanga kahle"</string>
    <string name="financed_privacy_locked_mode_category" msgid="3708288398912647751">"Uma idivayisi yakho ikhiyiwe, ungayisebenzisela kuphela uku-:"</string>
    <string name="financed_privacy_emergency_calls" msgid="1108183987142736497">"Yenza amakholi aphuthumayo"</string>
    <string name="financed_privacy_system_info" msgid="4158031444108708927">"Buka ulwazi lwesistimu olufana nelanga, isikhathi, isimo senethiwekhi, nebhethri"</string>
    <string name="financed_privacy_turn_on_off_device" msgid="3331566753152790571">"Vula noma uvale idivayisi yakho"</string>
    <string name="financed_privacy_notifications" msgid="5932303271274089968">"Buka izaziso nemiyalezo ebhaliwe"</string>
    <string name="financed_privacy_allowlisted_apps" msgid="8333040812194879963">"Finyelela ama-app avunyelwe umhlinzeki wekhredithi"</string>
    <string name="financed_privacy_fully_paid_category" msgid="9221763928564246923">"Uma usukhokhe inani eliphelele:"</string>
    <string name="financed_privacy_restrictions_removed" msgid="3182636815294595072">"Yonke imikhawulo iyasuswa kudivayisi"</string>
    <string name="financed_privacy_uninstall_creditor_app" msgid="6339004120497310705">"Ungakhipha i-app yombolekisi"</string>
    <string name="financed_device_info" msgid="3871860346697308342">"Ulwazi lwedivayisi oluhlinzekwe ngezezimali"</string>
    <string name="default_camera_app_title" msgid="6546248868519965998">"{count,plural, =1{I-app yekhamera}one{Ama-app wekhamera}other{Ama-app wekhamera}}"</string>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Uhlelo lokusebenza lekhalenda"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Uhlelo lokusebenza loxhumana nabo"</string>
    <string name="default_email_app_title" msgid="5411280873093244250">"{count,plural, =1{I-app yeklayenti ye-imeyili}one{Ama-app weklayenti e-imeyili}other{Ama-app weklayenti e-imeyili}}"</string>
    <string name="default_map_app_title" msgid="7569231732944853320">"Uhlelo lokusebenza lemephu"</string>
    <string name="default_phone_app_title" msgid="795025972645464135">"{count,plural, =1{I-app yefoni}one{Ama-app wefoni}other{Ama-app wefoni}}"</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">"Le divayisi"</string>
    <string name="storage_games" msgid="1176568610086802469">"Amageyimu"</string>
    <string name="storage_files" msgid="7968460921272772299">"Amafayela"</string>
    <string name="storage_images" msgid="2055893015567979387">"Izithombe"</string>
    <string name="storage_videos" msgid="6117698226447251033">"Amavidiyo"</string>
    <string name="storage_audio" msgid="5994664984472140386">"Umsindo"</string>
    <string name="storage_apps" msgid="3564291603258795216">"Ama-app"</string>
    <string name="storage_documents_and_other" msgid="3293689243732236480">"Amadokhumenti nokunye"</string>
    <string name="storage_system" msgid="8472410119822911844">"Isistimu"</string>
    <string name="storage_trash" msgid="2807138998886084856">"Udoti"</string>
    <string name="storage_trash_dialog_title" msgid="2296169576049935200">"Thulula udoti?"</string>
    <string name="storage_trash_dialog_ask_message" msgid="8982602137242358798">"Kukhona okungu-<xliff:g id="TOTAL">%1$s</xliff:g> kwamafayela kudoti. Zonke izinto zizosuswa ingunaphakade, futhi ngeke ukwazi ukuziphindisela."</string>
    <string name="storage_trash_dialog_empty_message" msgid="7334670765528691400">"Udoti awunalutho"</string>
    <string name="storage_trash_dialog_confirm" msgid="1707723334982760436">"Thulula udoti"</string>
    <string name="storage_usage_summary" msgid="4591121727356723463">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g> esetshenzisiwe"</string>
    <string name="storage_total_summary" msgid="7163360249534964272">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g> Ingqikithi"</string>
    <string name="clear_instant_app_data" msgid="5951258323364386357">"Sula uhlelo lokusebenza"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Ingabe uyafuna ukususa lolu hlelo lokusebenza olusheshayo?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Vula"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Amageyimu"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Isikhala esisetshenzisiwe"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(kukhishelwe umsebenzisi ongu-<xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(kukhutshazelwe umsebenzisi ongu-<xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Isevisi yokugcwalisa ngokuzenzekela"</string>
    <string name="default_autofill_app" msgid="372234803718251606">"Isevisi yokugcwalisa okuzenzakalelayo"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Amaphasiwedi"</string>
    <string name="credman_chosen_app_title" msgid="7735183808067729319">"Isevisi enconywayo"</string>
    <string name="credman_credentials" msgid="2620352336624160642">"Amasevisi angeziwe"</string>
    <string name="autofill_passwords_count" msgid="6359289285822955973">"{count,plural, =1{iphasiwedi e-#}one{amaphasiwedi angu-#}other{amaphasiwedi angu-#}}"</string>
    <string name="autofill_keywords" msgid="8598763328489346438">"okuzenzakalelayo, gcwalisa, gcwalisa ngokuzenzakalelayo, iphasiwedi"</string>
    <string name="credman_keywords" msgid="8305600680836806170">"idatha, ukhiye wokudlula, iphasiwedi"</string>
    <string name="credman_autofill_keywords" msgid="701180623776848914">"okuzenzakalelayo, gcwalisa, gcwalisa ngokuzenzakalelayo, idatha, ukhiye wokudlula, iphasiwedi"</string>
    <string name="credman_button_change" msgid="4072629639218503790">"Shintsha"</string>
    <string name="credman_button_open" msgid="7519871964170816850">"Vula"</string>
    <string name="credman_app_list_preference_none" msgid="2509646651254971448">"Akukho okukhethiwe"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&lt;b&gt;Qiniseka ukuthi wethemba lolu hlelo lokusebenza&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Google Autofill&gt;%1$s&lt;/xliff:g&gt; isebenzisa okusesikrinini sakho ukunquma okungagcwaliswa ngokuzenzakalela."</string>
    <string name="credman_autofill_confirmation_message" msgid="843829628024668466">"&lt;b&gt;Sebenzisa i-&lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt;?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Amaphasiwedi amasha, okhiye bokudlula, nolunye ulwazi kuzolondolozwa lapha kusukela manje kuqhubeke. I-&lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; ingase isebenzise okusesikrinini sakho ukuze inqume ukuthi yini engagcwaliswa ngokuzenzakalela."</string>
    <string name="credman_picker_title" msgid="8442086614222006564">"Isevisi ekhethwayo yamaphasiwedi, okhiye bokudlula amp;nokugcwalisa okuzenzakalelayo"</string>
    <string name="credman_confirmation_message_title" msgid="8847900085593880729">"Vala i-%1$s?"</string>
    <string name="credman_confirmation_message" msgid="2357324543658635239">"&lt;b&gt;Vala le sevisi?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Ulwazi olulondoloziwe olufana namaphasiwedi, okhiye bokudlula, izindlela zokukhokha, nolunye ulwazi ngeke lugcwaliswe lapho ungena ngemvume. Ukuze usebenzise ulwazi lwakho olulondoloziwe, khetha iphasiwedi, ukhiye wokudlula, noma isevisi yedatha."</string>
    <string name="account_dashboard_title_with_passkeys" msgid="6214673787161409996">"Amaphasiwedi, okhiye bokudlula nokugcwalisa okuzenzakalelayo"</string>
    <string name="credman_confirmation_message_new_ui" msgid="6126274509951156460">"&lt;b&gt;Vala wonke amasevisi?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Amaphasiwedi, okhiye bokudlula, nolunye ulwazi olulondoloziwe ngeke lutholakale ukuba lufakwe ngokuzenzakalela lapho ungena ngemvume"</string>
    <string name="credman_autofill_confirmation_message_new_ui" msgid="6222139222478822267">"&amp;;b&gt;Ishintsha isevisi oyincamelayo ukuze ithi &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt;?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Amaphasiwedi amasha, okhiye bokudlula, nolunye ulwazi luzolondolozwa lapha kusukela manje kuya phambili. &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; ingase isebenzise okusesikrinini sakho ukuze inqume ukuthi yini engagcwaliswa ngokuzenzakalela"</string>
    <string name="credman_enable_confirmation_message_title" msgid="1037501792652277829">"Isebenzisa i-%1$s?"</string>
    <string name="credman_confirmation_turn_off_positive_button" msgid="5678773011513369161">"Vala"</string>
    <string name="credman_confirmation_change_provider_positive_button" msgid="7732302992885116967">"Shintsha"</string>
    <string name="credman_limit_error_msg_title" msgid="1525814645803612135">"Ungaba namasevisi angu-5 kuphela avuliwe"</string>
    <string name="credman_limit_error_msg" msgid="2521803280130310063">"Vala okungenani isevisi eyodwa ukuze ufake enye"</string>
    <string name="credman_enable_confirmation_message" msgid="8407841892310870169">"I-%1$s isebenzisa okusesikrinini sakho ukuze inqume ukuthi yini engagcwaliswa ngokuzenzekela."</string>
    <string name="credman_error_message_title" msgid="4099557206946333568">"Amaphasiwedi, okhiye bokudlula nomkhawulo wamasevisi edatha"</string>
    <string name="credman_error_message" msgid="8334797097200415449">"Ungaba namaphasiwedi afika kwama-5, okhiye bokudlula namasevisi edatha asebenzayo ngesikhathi esifanayo. Vala isevisi ukuze ufake okwengeziwe."</string>
    <string name="credman_confirmation_message_positive_button" msgid="2812613187691345361">"Vala"</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Ukugcwalisa okuzenzakalelayo"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Ileveli lokuloga"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Izicelo eziningi ngesikhathi"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Amadathasethi amakhulu abonakalayo"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Setha kabusha kuye kumanani azenzakalelayo"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Izinketho zokugcwalisa ngokuzenzakalela zonjiniyela zisethwe kabusha"</string>
    <string name="location_category" msgid="3496759112306219062">"Indawo"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Isikhombi sendawo yebha yesimo"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Bonisa kuzo zonke izindawo, okufaka phakathi inethiwekhi nokuxhumeka"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Phoqa izikali ezigcwele ze-GNSS"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Landelela onke ama-constellation nezimvamisa ngomjikelezo ongenawo umsebenzi"</string>
    <string name="input_method_category" msgid="2252659253631639005">"Indlela yokufaka"</string>
    <string name="stylus_handwriting" msgid="2154591374132794563">"Umbhalo wesandla nge-stylus"</string>
    <string name="stylus_handwriting_summary" msgid="6333425895172696950">"Uma inikwe amandla, indlela yamanje Yokufaka ithola i-stylus MotionEvent uma Umhleli egxilile."</string>
    <string name="device_theme" msgid="5027604586494772471">"Itimu yedivayisi"</string>
    <string name="default_theme" msgid="4815428567082263639">"Okuzenzakalelayo"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Igama lenethiwekhi"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Bonisa igama lenethiwekhi kwibha yesimo"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Uhlelo lokusebenza olusheshayo"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Vala isiphathi sesitoreji?"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Buyekeza okuthi ungaphazamisi"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Misa isikhashana izikhangiso ukuze uhlale ugxilile"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Isici asitholakali"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Lesi sici sivaliwe ngoba sibambezela ifoni yakho"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Njalo bonisa ibhokisi lokusaphazeka"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Bonisa ibhokisi njalo izinhlelo zokusebenza zisaphazeka"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Khetha uhlelo lokusebenza olunikwe amandla lwe-ANGLE"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Alukho uhlelo lokusebenza olunikwe amandla lwe-ANGLE olusethiwe"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"Uhlelo lokusebenza olunikwe amandla lwe-ANGLE: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Okuncanyelwayo kwesishayeli semifanekiso"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Lungisa izilungiselelo zesishayeli semifanekiso"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Lapho kukhona izishayeli zemifanekiso eziningi, ungakhetha ukusebenzisa isishayeli semifanekiso esibuyekeziwe sezinhlelo zokusebenza ezifakwe kudivayisi."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Nikela amandla zonke izinhlelo zokusebenza"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Khetha i-Graphics Driver"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Okuzenzekelayo"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Umshayeli Wegeyimu"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Isishayeli Sikanjiniyela"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Umshayeli wemifanekiso yesistimu"</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">"Ukuhlola: Nika amandla I-ENGELI"</string>
    <string name="enable_angle_as_system_driver_summary" msgid="2170215556348477481">"Nika amandla I-ENGELI njengesishayeli sesistimu ye-OpenGL ES. Lesi sakhi ngesesilingo futhi asikwazi ukusebenzisana namanye ama-app wekhamera nevidiyo."</string>
    <string name="reboot_dialog_enable_angle_as_system_driver" msgid="2619263039763150810">"Ukuqalisa kabusha kuyadingeka ukuze ushintshe umshayeli wesistimu we-OpenGL ES"</string>
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"Ushintsho lokuhambisana kwe-app"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Guqula ushintsho lokuhambisana kohlelo lokusebenza"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Ushintsho olunikwe amandla oluzenzakalelayo"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Ushintsho olukhutshaziwe oluzenzakalelayo"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Izinguquko zokuhambelana kohlelo lokusebenza zingalungiswa kuphela kuzinhlelo zokusebenza ezingalungiswa amaphutha. Faka uhlelo lokusebenza olungalungiswa amaphutha bese uzama futhi"</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Kuncike kwesinye isilungiselelo"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"I-Akhawunti"</string>
    <string name="my_device_info_account_preference_summary" msgid="3510582677937510545">"ama-akhawunti angu-%d"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Igama ledivayisi"</string>
    <string name="my_device_info_basic_info_category_title" msgid="381963187269356548">"Ulwazi oluyisisekelo"</string>
    <string name="my_device_info_legal_category_title" msgid="7732792841537995127">"Ezomthetho nokubusayo"</string>
    <string name="my_device_info_device_details_category_title" msgid="4848438695638348680">"Imininingwane yedivayisi"</string>
    <string name="my_device_info_device_identifiers_category_title" msgid="2197063484127704153">"Izinkomba zedivayisi"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"Ulawulo lwe-Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Vumela uhlelo lokusebenza ukuthi lulawule i-Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Vumela lolu hlelo lokusebenza ukuthi luvule noma luvale i-Wi-Fi, luskene luphinde lulawule amanethiwekhi e-Wi-Fi, lungeze noma lususe amanethiwekhi, noma luqale i-hotspot yasendaweni kuphela"</string>
    <string name="change_nfc_tag_apps_title" msgid="91514009058149617">"Qalisa nge-NFC"</string>
    <string name="change_nfc_tag_apps_detail_switch" msgid="240286205725043561">"Vumela ukuqaliswa kokuskena kwe-NFC"</string>
    <string name="change_nfc_tag_apps_detail_summary" msgid="3338220223868942195">"Vumela le-app ukuthi iqalise uma umaka we-NFC uskeniwe.\nUma le mvume ivuliwe, i-app izotholakala njengokukhethwa kukho noma kunini uma kutholwa umaka."</string>
    <string name="media_output_title" msgid="8283629315159510680">"Dlala imidiya ku-"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Ukudlala i-<xliff:g id="LABEL">%s</xliff:g> kuvuliwe"</string>
    <string name="media_output_title_without_playing" msgid="3339321669132875821">"Umsindo uzodlala"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"Le divayisi"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Akutholakali ngesikhathi samakholi"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Thatha ikholi ku-"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"Le APN ayikwazi ukuguqulwa."</string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Vimbela ukukhala"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Cindezela amandla nevolumu ndawonye"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Isinqamumeli sokuvimbela ukukhala"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Dlidlizela"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Thulisa"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Dlidlizela"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Thulisa"</string>
    <string name="prevent_ringing_option_unavailable_lpp_summary" msgid="8070356204398144241">"Ukuze unike amandla, qala ngokushintsha okuthi \"Cindezela futhi ubambe inkinobho yamandla\" kube yimenyu yamandla."</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Imininingwane yenethiwekhi"</string>
    <string name="devices_title" msgid="649715719278562515">"Amadivayisi"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Khetha inethiwekhi"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Inqamukile"</string>
    <string name="network_connected" msgid="7637745547242487795">"Ixhunyiwe"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Iyaxhuma…"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Ayikwazanga ukuxhumeka"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"Awekho amanethiwekhi atholakele."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Ayikwazanga ukuthola amanethiwekhi. Zama futhi."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(kunqatshelwe)"</string>
    <string name="sim_card" msgid="6381158752066377709">"I-SIM"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"Ayikho i-SIM"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Lutho"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Idinga i-SIM ukuze ixhume"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Idinga i-SIM ye-<xliff:g id="WIRELESS_CARRIER">%s</xliff:g> ukuze ixhume"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Imodi yenethiwekhi ekhethwayo: i-WCDMA ekhethwayo"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Imodi yenethiwekhi ekhethwayo: i-GSM kuphela"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Imodi yenethiwekhi ekhethwayo: i-WCDMA kuphela"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Imodi yenethiwekhi ekhethwayo: i-GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Imodi yenethiwekhi ekhethwayo: i-CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Imodi yenethiwekhi ekhethwayo: i-CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Imodi yenethiwekhi ekhethwayo: i-CDMA kuphela"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Imodi yenethiwekhi ekhethwayo: i-EvDo kuphela"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Imodi yenethiwekhi ekhethwayo: i-CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Imodi yenethiwekhi ekhethwayo: i-LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Imodi yenethiwekhi ekhethwayo: i-GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Imodi yenethiwekhi ekhethwayo: i-CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Imodi yenethiwekhi encanyelwayo: I-LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Imodi yenethiwekhi ekhethwayo: Umhlaba jikelele"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Imodi yenethiwekhi ekhethwayo: i-LTE / WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Imodi yenethiwekhi encanyelwayo: i-LTE / GSM / UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Imodi yenethiwekhi ekhethwayo: i-LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Imodi yenethiwekhi encanyelwayo: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Imodi yenethiwekhi ekhethwayo: TDSCDMA / WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Imodi yenethiwekhi ekhethwayo: LTE / TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Imodi yenethiwekhi ekhethwayo: TDSCDMA / GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Imodi yenethiwekhi ekhethwayo: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Imodi yenethiwekhi ekhethwayo: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Imodi yenethiwekhi ekhethwayo: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Imodi yenethiwekhi ekhethwayo: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Imodi yenethiwekhi ekhethwayo: i-CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Imodi yenethiwekhi ekhethwayo: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Imodi yenethiwekhi encanyelwayo: I-NR kuphela"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Imodi yenethiwekhi encanyelwayo: I-NR / LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Imodi yenethiwekhi encanyelwayo: I-NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Imodi yenethiwekhi encanyelwayo: I-NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Imodi yenethiwekhi encanyelwayo: I-NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Imodi yenethiwekhi encanyelwayo: I-NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Imodi yenethiwekhi encanyelwayo: I-NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Imodi yenethiwekhi encanyelwayo: I-NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Imodi yenethiwekhi encanyelwayo: I-NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Imodi yenethiwekhi encanyelwayo: I-NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Imodi yenethiwekhi encanyelwayo: I-NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_5G_recommended" msgid="4769018972369031538">"5G (kunconyiwe)"</string>
    <string name="network_lte" msgid="2449425437381668780">"I-LTE (inconyiwe)"</string>
    <string name="network_4G" msgid="9018841362928321047">"I-4G (inconyiwe)"</string>
    <string name="select_automatically" msgid="2419752566747259155">"Khetha ngokuzenzakalela inethiwekhi"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Izilungiselelo zenkampani yenethiwekhi"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Misa isevisi yedatha"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Idatha yeselula"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Finyelela kudatha usebenzisa inethiwekhi yeselula"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"Ifoni izoshintshela ngokuzenzakalela kule nkampani yenethiwekhi uma iseduze"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="9176513507571883986">"Ayikho i-SIM etholakalayo"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Okuncamelayo kwamakholi"</string>
    <string name="sms_preference" msgid="7742964962568219351">"Okuncanyelwayo kwe-SMS"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Hlala ubuza njalo"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Engeza inethiwekhi"</string>
    <string name="default_for_calls" msgid="2788950217176988034">"Okuzenzakalelayo kwamakholi"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"Okuzenzakalelayo kwe-SMS"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"Okuzenzakalelayo kwamakholi ne-SMS"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"Okuzenzakalelayo kwedatha yeselula"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Idatha yeselula iyasebenza"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Idatha yeselula ivaliwe"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Iyatholakala"</string>
    <string name="mobile_network_list_add_more" msgid="5076722903436552813">"Engeza i-SIM"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Ukusebenza / i-SIM"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Ukungasebenzi / i-SIM"</string>
    <string name="mobile_network_active_esim" msgid="3984452275968408382">"Iyasebenza / eSIM"</string>
    <string name="mobile_network_inactive_esim" msgid="8777415108263057939">"Ayisebenzi / eSIM"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"Igama le-SIM nombala"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Igama"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Umbala (usetshenziswe izinhlelo zokusebenza ezihambisanayo)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Londoloza"</string>
    <string name="mobile_network_use_sim_on" msgid="5333182776279917886">"Sebenzisa le SIM"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Valiwe"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="7182341033728911879">"Ukuze uvale le SIM, khipha i-SIM card"</string>
    <string name="mobile_network_tap_to_activate" msgid="5280456487243915465">"Thepha ukuze wenze i-<xliff:g id="CARRIER">%1$s</xliff:g> SIM yakho isebenze"</string>
    <string name="mobile_network_erase_sim" msgid="5387971155494245850">"Sula i-eSIM"</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Uhlobo lwenethiwekhi oluncamelayo"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Shintsha imodi esebenzayo yenethiwekhi"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Uhlobo lwenethiwekhi oluncamelayo"</string>
    <string name="carrier_settings_version" msgid="3364919669057317776">"Inguqulo yamasethingi wenkampani yenethiwekhi"</string>
    <string name="call_category" msgid="641461844504128789">"Iyashaya"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Ukushaya kwevidiyo kwenkampani yenethiwekhi"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Ukukhetha isistimu"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"Sintsha imodi yokuzulazula ye-cdma"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Ukukhetha isistimu"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Inethiwekhi"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"Okubhalisile kwe-CDMA"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Shintsha phakathi kwe-RUIM/SIM ne-NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"Okubhalisile"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Ukubhalisa okuzenzakalelayo…"</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Vumela ukuhamba kwedatha?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Hlola ngomhlinzeki wakho wenethiwekhi ukuze uthole intengo."</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"Imodi yenethiwekhi engavumelekile <xliff:g id="NETWORKMODEID">%1$d</xliff:g>. Ziba."</string>
    <string name="satellite_setting_title" msgid="2543034229989047673">"Ukuyaleza kwesethelayithi"</string>
    <string name="satellite_setting_enabled_summary" msgid="3554127722727530845">"Thumela futhi wamukele umyalezo obhaliwe ngesethelayithi. Kubandakanywe ne-akhawunti yakho"</string>
    <string name="satellite_setting_disabled_summary" msgid="6789122487534159857">"Thumela futhi wamukele umyalezo obhaliwe ngesethelayithi. Akubandakanyiwe ne-akhawunti yakho."</string>
    <string name="keywords_satellite_setting" msgid="3312183289776517695">"Ukuyaleza kwesethelayithi"</string>
    <string name="category_name_about_satellite_messaging" msgid="3756205049485508340">"Mayelana nokulayeza kwesethelayithi"</string>
    <string name="title_about_satellite_setting" msgid="9212860038048311345">"Ungathumela futhi wamukele imiyalezo ebhaliwe ngesethelayithi njengengxenye ye-akhawunti efanelekayo ye-<xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="category_title_your_satellite_plan" msgid="3017895097366691841">"Uhlelo lwakho lwe-<xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="title_have_satellite_plan" msgid="2048372355699977947">"Ukuyaleza kwesethelayithi kubandakanywe ku-akhawunti yakho"</string>
    <string name="title_no_satellite_plan" msgid="2876056203035197505">"Ukuyaleza kwesethelayithi akubandakanyiwe ne-akhawunti yakho"</string>
    <string name="summary_add_satellite_setting" msgid="3815254731634052432">"Faka ukuyaleza kwesethelayithi"</string>
    <string name="category_name_how_it_works" msgid="585303230539269496">"Indlela esebenza ngayo"</string>
    <string name="title_satellite_connection_guide" msgid="3294802307913609072">"Uma ungenayo inethiwekhi yeselula"</string>
    <string name="summary_satellite_connection_guide" msgid="3496123195218418456">"Ifoni yakho izoxhuma ngokuzenzakalela kusethelayithi. Ngokuxhuma okuncono, gcina isibhakabhaka sikhanya bha."</string>
    <string name="title_supported_service" msgid="4275535165812691571">"Ngemva kokuthi ifoni yakho ixhume kusethelayithi"</string>
    <string name="summary_supported_service" msgid="4320535903444834786">"Ungathumelela noma ubani umyalezo, okubandakanya amasevisi ezimo eziphuthumayo. Ifoni yakho izophinde ixhume kunethiwekhi yeselula uma itholakala."</string>
    <string name="satellite_setting_summary_more_information" msgid="4008690241760925372">"Ukuyaleza kwesethelayithi kungathatha isikhathi eside futhi kutholakala kuphela kwezinye izindawo, Isimo sezulu nokwakheka okuthile kungenzeka kuthinte ukuxhumana nesethelayithi yakho. Ukufona ngesethelayithi akutholakali.\n\nKungenzeka kuthathe isikhathi esithile ukuze ushintsho ku-akhawuntti yakho ukuthi lubonakale kumaSethingi. Xhumana ne-<xliff:g id="CARRIER_NAME">%1$s</xliff:g> ngemininingwane."</string>
    <string name="more_about_satellite_messaging" msgid="3385673133561348509">"Okwengeziwe mayelana nokuyaleza kwesethelayithi"</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Amagama wephoyinti lokufinyelela"</string>
    <string name="keywords_access_point_names" msgid="8174967126858505945">"i-apn"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Ayitholakali uma ixhumeke ku-<xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"Bona okuningi"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"Vula i-<xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name" msgid="4842051610633654278">"Vula i-SIM?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"Shintshela ku-<xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"Shintshela ekusebenziseni iSIM card lakho?"</string>
    <string name="sim_action_switch_sub_dialog_mep_title" msgid="933856847099933004">"Sebenzisa i-<xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="7474905814976249607">"I-SIM e-1 kuphela engavulwa ngesikhathi.\n\nUkushintshela ku-<xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> angeke kukhansele isevisi yakho ye-<xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="6415848271400253954">"I-eSIM e-1 kuphela ingavulwa ngesikhathi.\n\nUkushintshela ku-<xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> ngeke kukhansele isevisi yakho ye-<xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="421658355882679837">"I-SIM e-1 kuphela engavulwa ngesikhathi.\n\nUkushintsha angeke kukhansele isevisi yakho ye-<xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_mep_text" msgid="8348764755143679582">"Ungasebenzisa ama-SIM ama-2 noma kunini. Ukuze usebenzise i-<xliff:g id="CARRIER_NAME">%1$s</xliff:g>, vala enye i-SIM."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Shintshela ku-<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">"Vala i-<xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_info_outline_for_turning_off" msgid="1617619100229136888">"Ukuvala i-SIM ngeke kukhansele isevisi yakho"</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="8144175623622669136">"Yenza i-SIM yakho isebenze…"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="697127154780501304">"Ukushintshela ku-<xliff:g id="CARRIER_NAME">%1$s</xliff:g>…"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="2718084141744769701">"Ayikwazi ukushintsha ama-SIM"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="8332742656111984482">"Kukhona okungahambanga kahle. Ayikwazi ukushintsha ama-SIM."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"Vala i-<xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"Vala i-SIM?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"Ivala i-SIM<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="1808735136395980905">"Ayikwazi ukuvala i-SIM"</string>
    <string name="privileged_action_disable_fail_text" msgid="6236231745255527458">"Kukhona okungahambanga kahle futhi i-SIM yakho ayikwazanga ukuvalwa."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"Sebenzisa ama-SIM angu-2?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"Le divayisi ingaba nama-SIM angu-2 ngesikhathi esisodwa. Ukuze uqhubeke nokusebenzisa i-SIM engu-1 ngesikhathi, thepha okuthi \"Cha ngiyabonga\"."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Qalisa kabusha idivayisi?"</string>
    <string name="sim_action_yes" msgid="8076556020131395515">"Yebo"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Qala kabusha"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"Cha ngiyabonga"</string>
    <string name="sim_action_cancel" msgid="2668099867029610910">"Khansela"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Shintsha"</string>
    <string name="sim_action_turn_off" msgid="3506698692916473000">"Vala"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"Akukwazi ukwenza i-SIM isebenze"</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Zama ukuvula i-SIM futhi. Inkinga iyaqhubeka, qala kabusha idivayisi yakho."</string>
    <string name="sim_onboarding_bottomsheets_title" msgid="143711121394213711">"Setha i-SIM yakho"</string>
    <string name="sim_onboarding_bottomsheets_msg" msgid="7367245016476460849">"Setha okuncamelayo kwenethiwekhi yakho yeselula ukuze usebenzise ama-SIM amaningi kule divayisi"</string>
    <string name="sim_onboarding_label_sim_title" msgid="273162565849288273">"Lebula ama-SIM wakho"</string>
    <string name="sim_onboarding_label_sim_msg" msgid="5105859235219529056">"Uzobona lawa malebula lapho wenza amakholi, uthumela imiyalezo, futhi usebenzisa idatha, futhi Nakumasethingi"</string>
    <string name="sim_onboarding_label_sim_dialog_title" msgid="5839073125605286120">"Ilebula ye-SIM"</string>
    <string name="sim_onboarding_label_sim_dialog_label" msgid="9020433985426525185">"Ilebula"</string>
    <string name="sim_onboarding_select_sim_title" msgid="5895262188167744055">"Khetha ukuthi yimaphi ama-SIM ongawasebenzisa"</string>
    <string name="sim_onboarding_select_sim_msg" msgid="5638859405391915048">"Ungasebenzisa ama-SIM angu-2 ngesikhathi"</string>
    <string name="sim_onboarding_primary_sim_title" msgid="2793090401371135675">"Setha ama-SIM wakho ayinhloko"</string>
    <string name="sim_onboarding_primary_sim_msg" msgid="5484656671490558032">"Khetha ukuthi yimaphi ama-SIM ongawasebenzisa ngokuzenzakalelayo kumakholi, ekuthumeleni imiyalezo, nedatha"</string>
    <string name="primary_sim_title" msgid="2508161011657571566">"Ama-SIM wakho ayinhloko"</string>
    <string name="primary_sim_calls_title" msgid="4961189133582615685">"Amakholi"</string>
    <string name="primary_sim_texts_title" msgid="1287584042733097749">"Ukuthumela imiyalezo"</string>
    <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Ukushintsha idatha okuzenzekelayo"</string>
    <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Sebenzisa idatha evela kunoma iyiphi i-SIM kuye ngokukhava nokutholakala"</string>
    <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Idatha kuphela"</string>
    <string name="sim_onboarding_setup" msgid="5750393553605388463">"Setha"</string>
    <string name="sim_onboarding_next" msgid="6415025179929475355">"Okulandelayo"</string>
    <string name="sim_onboarding_progressbar_turning_sim_on" msgid="1163318788393361574">"Ivula i-<xliff:g id="CARRIER_NAME">%1$s</xliff:g>…"</string>
    <string name="mobile_network_spn_title" msgid="3053793174495329077">"Inethiwekhi yeselula"</string>
    <string name="mobile_network_phone_number_title" msgid="2090794402855021784">"Inombolo yefoni"</string>
    <string name="mobile_network_sim_label_color_title" msgid="2401352348041132876">"Ilebula ye-SIM nombala"</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Ukwenziwa kusebenze kwenethiwekhi"</string>
    <string name="sim_switch_channel_id" msgid="4927038626791837861">"Ukushintsha inkampani yenethiwekhi"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="975447139749692794">"I-<xliff:g id="CARRIER_NAME">%1$s</xliff:g> SIM yakho iyasebenza"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Thepha ukuze ubuyekeze izilungiselelo ze-SIM"</string>
    <string name="switch_to_removable_notification" msgid="7640342063449806296">"Ishintshelwe ku-<xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="switch_to_removable_notification_no_carrier_name" msgid="7384856964036215338">"Ishintshele kwenye inkampani yenethiwekhi"</string>
    <string name="network_changed_notification_text" msgid="2407908598496951243">"Inethiwekhi yakho ishintshile"</string>
    <string name="dsds_notification_after_suw_title" msgid="3738898232310273982">"Setha enye i-SIM yakho"</string>
    <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"Khetha i-SIM esebenzayo noma sebenzisa ama-SIM angu-2 ngesikhathi esisodwa"</string>
    <string name="choose_sim_title" msgid="66509047151583877">"Khetha i-SIM ozoyisebenzisa"</string>
    <string name="choose_sim_text" msgid="8992163497852069924">"{count,plural, =1{Kutholakala i-SIM engu-1 kule divayisi, kodwa iyodwa kuphela engasetshenziswa ngesikhathi}=2{Kutholakala ama-SIM angu-2 kule divayisi, kodwa eyodwa kuphela engasetshenziswa ngesikhathi}one{Kutholakala ama-SIM angu-# kule divayisi, kodwa eyodwa kuphela engasetshenziswa ngesikhathi}other{Kutholakala ama-SIM angu-# kule divayisi, kodwa eyodwa kuphela engasetshenziswa ngesikhathi}}"</string>
    <string name="choose_sim_activating" msgid="6485547671356386998">"Ivula<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="choose_sim_could_not_activate" msgid="866488735834045525">"Ayikwazanga ukuvula le SIM khona manje"</string>
    <string name="switch_sim_dialog_title" msgid="5407316878973237773">"Sebenzisa i-<xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="switch_sim_dialog_text" msgid="7530186862171635464">"I-<xliff:g id="CARRIER_NAME">%1$s</xliff:g> izosetshenziselwa idatha yeselula, amakholi, ne-SMS."</string>
    <string name="switch_sim_dialog_no_switch_title" msgid="809763410787744247">"Awekho ama-SIM asebenzayo atholakalayo"</string>
    <string name="switch_sim_dialog_no_switch_text" msgid="7053939850026876088">"Ukuze usebenzise idatha yeselula, izici zokushaya, ne-MMS kamuva, iya kuzilungiselelo zakho zenethiwekhi"</string>
    <string name="sim_card_label" msgid="6263064316075963775">"I-SIM"</string>
    <string name="erase_sim_dialog_title" msgid="4742077437653028326">"Sula le eSIM?"</string>
    <string name="erase_sim_dialog_text" msgid="1406141218170595272">"Lokhu kususa isevisi ye-<xliff:g id="CARRIER_NAME_A">%1$s</xliff:g> evela kule divayisi, kodwa uhlelo lwakho lwe-<xliff:g id="CARRIER_NAME_B">%1$s</xliff:g> ngeke lukhanselwe."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Sula"</string>
    <string name="erasing_sim" msgid="4237180547590463930">"Isula i-eSIM…"</string>
    <string name="erase_sim_fail_title" msgid="1445700500168357303">"Ayikwazi ukusula i-eSIM"</string>
    <string name="erase_sim_fail_text" msgid="6898841004987411547">"Kukhona okungahambanga kahle futhi le-eSIM ayikasulwa.\n\nQala kabusha idivayisi yakho bese uphinde uyazama."</string>
    <string name="wifi_warning_dialog_title" msgid="7328515476966592390">"Xhuma ku-Wi-Fi ngaphambi kokusula"</string>
    <string name="wifi_warning_dialog_text" msgid="6584060137703953174">"Lokhu kwenza kube lula ukusebenzisa i-eSIM yakho futhi ngokuzayo ngaphandle kokudinga ukuxhumana nenkampani yakho yenethiwekhi"</string>
    <string name="wifi_warning_continue_button" msgid="8171574741789688214">"Sula noma kunjalo"</string>
    <string name="wifi_warning_return_button" msgid="6226063181583906340">"KULUNGILE"</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Xhuma kudivayisi"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"Uhlelo lokusebenza le-<xliff:g id="APPNAME">%1$s</xliff:g> lifuna ukusebenzisa inethiwekhi ye-Wi‑Fi ukuxhuma kudivayisi yakho"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Awekho amadivayisi atholiwe. Yenza isiqinisekiso sokuthi amadivayisi avuliwe futhi ayatholakala ukuze axhumeke."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Zama futhi"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Okuthile kuvelile. Uhlelo lokusebenza likhansele isicelo sokukhetha idivayisi."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Ukuxhumeka kuphumelele"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Ukuxhumeka kuhlulekile"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Bonisa konke"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Iseshela idivayisi…"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Ixhumeka kudivayisi…"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Kwesobunxele"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Okungakwesokudla"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Isimo"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Iphaneli yezilungiselelo"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Phoqelela imodi yedeskithophu"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Phoqelela imodi yedeskithophu yokuhlola esibukisweni sesibili"</string>
    <string name="enable_non_resizable_multi_window" msgid="6832903754625404477">"Nika amandla okungashintsheki usayizi emawindini amaningi"</string>
    <string name="enable_non_resizable_multi_window_summary" msgid="3275763753261901999">"Ivumela izinhlelo zokusebenza ezingashintsheki usayizi ukuthi zibe emawindini amaningi"</string>
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Bhala ngaphezulu isici sokuphoqelela okumnyama"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Ibhala ngaphezulu isici sokuphoqelela okumnyama ukuthi ihlale sivulekile"</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Ubumfihlo"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Izimvume, umsebenzi we-akhawunti, idatha yomuntu siqu"</string>
    <string name="privacy_controls_title" msgid="1383047169455206604">"Izilawuli"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Susa"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Gcina"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"Susa lesi isiphakamiso?"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Isitoreji siphansi. <xliff:g id="PERCENTAGE">%1$s</xliff:g> osetshenzisiwe - <xliff:g id="FREE_SPACE">%2$s</xliff:g> okukhululekile"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Thumela impendulo"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Ungathanda ukunikeza impendulo kulesi siphakamiso?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"<xliff:g id="COPY_CONTENT">%1$s</xliff:g> kukopishelwe ebhodini lokunamathisela."</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Ukusetshenziswa kokufinyeleleka"</string>
    <string name="accessibility_usage_summary" msgid="4348285359995227813">"{count,plural, =1{I-app e-1 enokufinyelela okugcwele kudivayisi yakho}one{Ama-app angu-# anokufinyelela okugcwele kudivayisi yakho}other{Ama-app angu-# anokufinyelela okugcwele kudivayisi yakho}}"</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Ulwazi olubalulekile"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"QHUBEKA"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"CHA NGIYABONGA"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Indawo"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="1417004513415772582">"Inkampani yakho yenethiwekhi ingaqoqa indawo yakho uma usebenzisela le sevisi amakholi aphuthumayo.\n\nVakashela inqubomgomo yobumfihlo yenkampani yakho yenethiwekhi ukuze uthole imininingwane."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Ungalahlekelwa ukufinyelela kunoma isiphi isikhathi esisele noma kudatha. Hlola nomhlinzeki wakho ngaphambi kokususa."</string>
    <string name="content_capture" msgid="868372905432812238">"Okuqukethwe kohlelo lokusebenza"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Vumela izinhlelo zokusebenza ukuthumela okuqukethwe kusistimu ye-Android"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Thwebula ukulahlwa kwehephu yesistimu"</string>
    <string name="development_memtag_page_title" msgid="3546667618748029188">"Isandiso Sokumaka Inkumbulo"</string>
    <string name="development_memtag_intro" msgid="8032596625527637164">"Isandiso Sokumaka Inkumbulo (MTE) senza kube lula ukuthola izinkinga zokuphepha kwenkumbulo ku-app yakho futhi senze ikhodi yomdabu kulo ivikeleke kakhulu."</string>
    <string name="development_memtag_footer" msgid="5681925148773626562">"Ukuvula i-MTE kungase kubangele ukusebenza kancane kwedivayisi."</string>
    <string name="development_memtag_learn_more" msgid="8961984806973926704">"Funda kabanzi mayelana ne-MTE"</string>
    <string name="development_memtag_toggle" msgid="2474420239518386894">"Nika amandla i-MTE uze uyivale"</string>
    <string name="development_memtag_reboot_message_on" msgid="8100075676107327847">"Uzodinga ukuqala kabusha idivayisi yakho ukuze uvule i-MTE."</string>
    <string name="development_memtag_reboot_message_off" msgid="3703925647922079456">"Uzodinga ukuqala kabusha idivayisi yakho ukuze uvale i-MTE."</string>
    <string name="reboot_with_mte_title" msgid="2320125810211279">"Nika amandla i-MTE yeseshini eyodwa"</string>
    <string name="reboot_with_mte_message" msgid="1232881567956207641">"Isistimu izoqalisa kabusha futhi ivumele ukuzwa Ngesandiso Sokumaka Inkumbulo (MTE). I-MTE ingase ithonye kabi ukusebenza nokuzinza kwesistimu. Izosethwa kabusha ekuqaliseni okuhambisanayo okulandelayo."</string>
    <string name="reboot_with_mte_summary" msgid="3896537791216432882">"Qala kabusha iseshini eyodwa nge-MTE enikwe amandla"</string>
    <string name="reboot_with_mte_already_enabled" msgid="4439168867613407167">"I-MTE isivele inikwe amandla"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Ukulahlwa kwehephu yesistimu yokuthwebula"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Ayikwazanga ukuthwebula ukulahlwa kwehephu yesistimu"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Thwebula ngokuzenzakalela ukulahlwa kwehephu yesistimu"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Thwebula ngokuzenzakalela ukulahlwa kwehephu kwesistimu ye-Android uma isebenzisa imemori enkulu kakhulu"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Nqamula"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Amakholi aphuthumayo"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"Amakholi aphuthumayo ngokushaya kwe-Wi-Fi awasekelwe inkampani yakho yenethiwekhi.\nIdivayisi ishintsha ngokuzenzakalela iye kunethiwekhi yeselula ukuze yenze ikholi ephuthumayo.\nAmakholi aphuthumayo akhonakala kuphela ezindaweni ezinokufakwa kweselula."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Sebenzisa i-Wi‑Fi ngamakholi ukuthuthukisa ikhwalithi"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Umlayezo ongenayo we-MMS"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"Ayikwazi ukuthumela umlayezo we-MMS"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Thepha ukuze uvumele ukulayeza kwe-MMS ku-<xliff:g id="OPERATOR_NAME">%1$s</xliff:g> uma idatha yeselula ivaliwe"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"Umlayezo we-MMS"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Khipha ngokuhlangana kwe-SIM"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Ukusebenzisa i-<xliff:g id="OPERATOR_NAMES">%1$s</xliff:g> kungakhawulelwa umsebenzi. Thepha ukuze ufunde kabanzi."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"Inhlanganisela ye-SIM"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Ulwazi lwenqubomgomo yakho yomsebenzi"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Izilungiselelo eziphethwe umlawuli wakho we-IT"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"I-GPU"</string>
    <string name="enable_16k_pages" msgid="5009476566957520607">"Qalisa ngosayizi wekhasi ongu-16K"</string>
    <string name="enable_16k_pages_summary" msgid="428117226069445198">"Qalisa idivayisi ngosayizi wekhasi ongu-16K wekheneli ehambisanayo"</string>
    <string name="confirm_enable_16k_pages_title" msgid="6751570067857011642">"Qalisa ngamakhasi angu-16KB wekheneli ehambisanayo?"</string>
    <string name="confirm_enable_16k_pages_text" msgid="702888115148257215">"ISIXWAYISO: Amanye ama-application angase angahambisani nale modi. Idivayisi izoqalisa ngemva kokuqinisekisa."</string>
    <string name="confirm_enable_4k_pages_title" msgid="626987400420355263">"Qalisa ngamakhasi angu-4KB wekheneli ehambisanayo?"</string>
    <string name="confirm_enable_4k_pages_text" msgid="6168921566226074524">"Idivayisi izoqalisa ngemva kokuqinisekisa."</string>
    <string name="toast_16k_update_failed_text" msgid="8888858987184345567">"Ihlulekile ukubuyekeza ikheneli ibe amakhasi angu-16KB ekheneli ehambisanayo."</string>
    <string name="progress_16k_ota_title" msgid="2117218313875523741">"Yenza izinguquko"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Isibambi sombiko wesiphazamiso"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Icacisa ukuthi uluphi uhlelo lokusebenza oluphatha isinqamuleli sombiko wesiphazamisi kudivayisi yakho."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Okomuntu siqu"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Umsebenzi"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Okuzenzakalelayo kwesistimu"</string>
    <string name="default_app_none" msgid="5420632042222036264">"Lutho"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"Lokhu kukhetha akusavumelekile. Zama futhi."</string>
    <string name="power_menu_setting_name" msgid="2394440932633137229">"Cindezela futhi ubambe inkinobho yokuvula nokuvala"</string>
    <string name="power_menu_long_press_category_title" msgid="1051146091093775002">"Cindezela futhi ubambe inkinobho yamandla ukuze ufinyelele"</string>
    <string name="power_menu_long_press_for_power_menu_title" msgid="477584639843663599">"Imenyu yamandla"</string>
    <string name="power_menu_long_press_for_assistant_title" msgid="6557738348262616455">"Umsizi odijithali"</string>
    <string name="power_menu_summary_long_press_for_assistant" msgid="32706459458422952">"Finyelela umsizi odijithali"</string>
    <string name="power_menu_summary_long_press_for_power_menu" msgid="7617247135239683710">"Finyelela imenyu yamandla"</string>
    <string name="lockscreen_privacy_not_secure" msgid="3251276389681975912">"Ukuze usebenzise, qala ngokusetha ukukhiya kwesikrini"</string>
    <string name="power_menu_power_volume_up_hint" msgid="5619917593676125759">"Imenyu yamandla:\nCindezela inkinobho yamandla kanye nenkinobho yokunyusa ivolumu ngesikhathi esifanayo"</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="1169955014711158873">"Vimba ukukhalisa:\nCindezela inkinobho yevolumu ukuze uthole isinqamuleli"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_title" msgid="1626808509158422185">"Isikhathi sokucindezela futhi ubambe"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_summary" msgid="7550610071666801935">"Lungisa ukuzwela ngokukhetha ukuthi uyicindezela futhi ubambe isikhathi esingakanani inkinobho yamandla"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_low_label" msgid="3430099983480845635">"Okufushane"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_high_label" msgid="2059686170350829156">"Kude"</string>
    <string name="lockscreen_privacy_wallet_setting_toggle" msgid="4188327143734192000">"Bonisa i-wallet"</string>
    <string name="lockscreen_privacy_wallet_summary" msgid="3984851951621168573">"Vumela ukufinyelela ku-wallet ekukhiyeni isikrini"</string>
    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle" msgid="1856477548806618829">"Bonisa iskena sekhodi ye-QR"</string>
    <string name="lockscreen_privacy_qr_code_scanner_summary" msgid="4577409244972250235">"Vumela ukufinyelela kuskena sekhodi ye-QR kusukela ekukhiyeni isikrini"</string>
    <string name="lockscreen_privacy_controls_setting_toggle" msgid="7445725343949588613">"Bonisa izilawuli zensiza"</string>
    <string name="lockscreen_privacy_controls_summary" msgid="7522918441738915364">"Ukusuka esikrinini esikhiyiwe"</string>
    <string name="lockscreen_trivial_controls_setting_toggle" msgid="2174300719855112358">"Sebenzisa izilawuli zedivayisi"</string>
    <string name="lockscreen_trivial_disabled_controls_summary" msgid="7593626010580689155">"Ukuze usebenzise, qala ngokuvula okuthi \"Bonisa izilawuli zedivayisi\""</string>
    <string name="lockscreen_double_line_clock_summary" msgid="4109235686687860393">"Usayizi wewashi uyashintsha kuye ngokuqukethwe kokukhiya isikrini"</string>
    <string name="lockscreen_double_line_clock_setting_toggle" msgid="802271087416091548">"Iwashi elishintshashintshayo"</string>
    <string name="lockscreen_quick_affordances_title" msgid="8615741551327565793">"Izinqamuleli"</string>
    <plurals name="lockscreen_quick_affordances_summary" formatted="false" msgid="4225396036524703997">
      <item quantity="one"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="other"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
    </plurals>
    <string name="rtt_settings_title" msgid="7049259598645966354"></string>
    <string name="rtt_settings_no_visible" msgid="7440356831140948382"></string>
    <string name="rtt_settings_visible_during_call" msgid="7866181103286073700"></string>
    <string name="rtt_settings_always_visible" msgid="2364173070088756238"></string>
    <string name="volte_5G_limited_title" msgid="5908052268836750629">"Vala i-VoLTE?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"Lokhu kuphinda kuvale ukuxhumeka kwakho kwe-5G.\nNgesikhathi sekholi yezwi, awukwazi ukusebenzisa i-inthanethi futhi ezinye izinhlelo zokusebenza kungenzeka zingasebenzi."</string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Misa ukukhishwa kwama-app enziwe inqolobane"</string>
    <string name="blob_never_expires_text" msgid="7293376386620106623">"Asiphelelwa isikhathi."</string>
    <string name="accessor_never_expires_text" msgid="4647624492147788340">"Isivumelwano sokuqasha asiphelelwa isikhathi."</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Vumela ukumbozwa kwesikrini kokuthi Amasethingi"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Vumela izinhlelo zokusebenza ezingabonisa ngaphezulu kwezinye izinhlelo zokusebenza ukumboza izikrini zokuthi Amasethingi"</string>
    <string name="allow_mock_modem" msgid="3832264806530479214">"Vumela Imodemu ye-Mock"</string>
    <string name="allow_mock_modem_summary" msgid="9097416612748005374">"Vumela le divayisi ukuthi iqalise isevisi Yemodemu ye-Mock ukuze uhlole izinsimbi. Ungakuniki amandla lokhu ngesikhathi sokusetshenziswa okuvamile kwefoni"</string>
    <string name="disable_screen_share_protections_for_apps_and_notifications" msgid="4987116103699222633">"Khubaza izivikelo zokwabelana kwesikrini"</string>
    <string name="disable_screen_share_protections_for_apps_and_notifications_summary" msgid="932295234626582052">"Ikhubaza i-app esetshenzisiwe yesistimu kanye nokuvikelwa kwezaziso phakathi nokwabelana kwesikrini"</string>
    <string name="media_controls_title" msgid="403271085636252597">"Imidiya"</string>
    <string name="media_controls_resume_title" msgid="855076860336652370">"Phina i-media player"</string>
    <string name="media_controls_resume_description" msgid="3163482266454802097">"Ukuze uqalise kabusha ngokushesha ukudlala, i-media player ihlala ivuliwe Kumasethingi asheshayo"</string>
    <string name="media_controls_lockscreen_title" msgid="2188311721857512510">"Bonisa imidiya ekukhiyeni isikrini"</string>
    <string name="media_controls_lockscreen_description" msgid="3320333660404439510">"Ukuze uqalise kabusha ukudlala ngokushesha, i-media player ihlala ivuliwe ekukhiyeni isikrini"</string>
    <string name="media_controls_recommendations_title" msgid="3012692549413927608">"Bonisa izincomo zemidiya Zomsizi"</string>
    <string name="media_controls_recommendations_description" msgid="7596498733126824030">"Ngokususelwe kumsebenzi wakho"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Fihla umdlali"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Bonisa umdlali"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"imidiya"</string>
    <string name="camera_extensions_fallback_title" msgid="3604579046777004989">"Vumela izandiso zesofthiwe yekhamera"</string>
    <string name="camera_extensions_fallback_description" msgid="6939818294458854536">"Inika amandla ukufakwa kwesofthiwe okuzenzekalelayo kwezakhi zekhamera ezithuthukisiwe, njengevidiyo ye-Eyes Free."</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"I-Bluetooth izovuleka"</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"I-inthanethi"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"Ama-SIM"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Amakholi ne-SMS"</string>
    <string name="calls_and_sms_category" msgid="3788238090898237767">"Ukushaya kwe-Wi-Fi"</string>
    <string name="calls_sms_wfc_summary" msgid="3940529919408667336">"Yenza futhi yamukela amakholi nge-Wi‑Fi"</string>
    <string name="calls_preference_title" msgid="7536882032182563800">"Amakholi"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"I-SMS"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"okuncanyelwayo"</string>
    <string name="calls_sms_calls_preferred" msgid="9004261125829377885">"kuyanconyelwa kumakholi"</string>
    <string name="calls_sms_sms_preferred" msgid="3855778890660922711">"kuyancanyelwa kuma-SMS"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"ayitholakali"</string>
    <string name="calls_sms_temp_unavailable" msgid="8602291749338757424">"Akutholakali okwesikhashana"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"Ayikho i-SIM"</string>
    <string name="network_and_internet_preferences_title" msgid="8635896466814033405">"Okuncamelayo kwenethiwekhi"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"uxhumano lenethiwekhi, i-inthanethi, okungenantambo, idatha, i-wifi, i-wi-fi, i-wi fi, iselula, iselula, inkampani yekholi, i-4g, i-3g, i-2g, i-lte"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Setha kabusha i-inthanethi yakho?"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Isetha kabusha i-inthanethi yakho…"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Lungisa ukuxhumeka"</string>
    <string name="networks_available" msgid="3299512933684383474">"Amanethiwekhi ayatholakala"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Ukuze ushintshe amanethiwekhi, nqamula i-ethernet"</string>
    <string name="carrier_wifi_offload_title" msgid="7263365988016247722">"Uxhumano lwe-W+"</string>
    <string name="carrier_wifi_offload_summary" msgid="2980563718888371142">"Vumela i-Google Fi ukuthi isebenzise amanethiwekhi we-W+ ukuthuthukisa isivinini nenethiwekhi"</string>
    <string name="carrier_wifi_network_title" msgid="5461382943873831770">"Inethiwekhi ye-W+"</string>
    <string name="sim_category_title" msgid="2341314000964710495">"SIM"</string>
    <string name="downloaded_sim_category_title" msgid="2876988650413179752">"I-eSIM"</string>
    <string name="downloaded_sims_category_title" msgid="487799905978489922">"Ama-eSIM"</string>
    <string name="sim_category_active_sim" msgid="3077009911935592178">"Kuvuliwe"</string>
    <string name="sim_category_inactive_sim" msgid="7351553344148400450">"Kuvaliwe"</string>
    <string name="sim_category_default_active_sim" msgid="1208194173387987231">" / Okuzenzakalelayo kwe-<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="default_active_sim_calls" msgid="2390973682556353558">"amakholi"</string>
    <string name="default_active_sim_sms" msgid="8041498593025994921">"I-SMS"</string>
    <string name="default_active_sim_mobile_data" msgid="6798083892814045301">"idatha yeselula"</string>
    <string name="wifi_scan_notify_message" msgid="1331238142061476869">"Ukuze kuthuthukiswe ukuzizwela kwedivayisi, ama-app namasevisi asengaskena amanethiwekhi e-Wi-Fi noma kunini, nanoma i-Wi-Fi ivaliwe. Lokhu kungasetshenziselwa, njengesibonelo, ukuthuthukisa izakhi ezisuselwa endaweni namasevisi. Ungashintsha lokhu kumasethingi Wokuskena i-Wi-Fi."</string>
    <string name="wifi_scan_change" msgid="8438320311511852918">"Shintsha"</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">"Ixhunyiwe"</string>
    <string name="mobile_data_temp_connection_active" msgid="3430470299756236413">"Ixhume okwesikhashana"</string>
    <string name="mobile_data_temp_using" msgid="5211002380149434155">"Ukusebenzisa i-<xliff:g id="SUBNAME">%1$s</xliff:g> okwesikhashana"</string>
    <string name="mobile_data_no_connection" msgid="905897142426974030">"Alukho uxhumano"</string>
    <string name="mobile_data_off_summary" msgid="1884248776904165539">"Idatha yeselula ngeke ikwazi ukuxhuma ngokuzenzekelayo"</string>
    <string name="mobile_data_disable_title" msgid="8438714772256088913">"Vala idatha yeselula?"</string>
    <string name="mobile_data_disable_message" msgid="7829414836454769970">"Ngeke ube nokufinyelela kudatha noma ku-inthanethi nge-<xliff:g id="CARRIER">%s</xliff:g>. I-inthanethi izotholakala kuphela nge-Wi‑Fi."</string>
    <string name="mobile_data_disable_message_default_carrier" msgid="4449469407705838612">"inkampani yakho yenethiwekhi"</string>
    <string name="not_allowed_by_ent" msgid="1958611623122304411">"Ayivunyelwe yinhlangano yakho"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Akutholakali ngoba imodi yesikhathi sokulala ivuliwe"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Ukusetha kabusha ukubaluleka kwesaziso kuqediwe."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Izinhlelo zokusebenza"</string>
    <string name="bluetooth_message_access_notification_content" msgid="5111712860712823893">"Idivayisi engathenjwa ifuna ukufinyelela imiyalezo yakho. Thepha ukuze uthole imininingwane"</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Vumela ukufinyelela kumilayezo?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="7186694737578788487">"Idivayisi ye-Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, ifuna ukufinyelela imiyalezo yakho.\n\nAwuzange uxhume ku-<xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> ngaphambilini."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="9175220052703433637">"Idivayisi ifuna ukufinyelela koxhumana nabo nakurekhodi lamakholi. Thepha ukuze uthole imininingwane"</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Vumela ukufinyelela koxhumana nabo nakurekhodi lamakholi?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"Idivayisi ye-Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, ifuna ukufinyelela oxhumana nabo nerekhodi lamakholi. Lokhu kufaka phakathi nedatha emayelana namakholi angenayo naphumayo.\n\nAwukaze uxhumeke ku-<xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> ngaphambilini."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Ukugqama"</string>
    <string name="category_name_lock_display" msgid="8310402558217129670">"Khiya isiboniso"</string>
    <string name="category_name_appearance" msgid="8287486771764166805">"Ukubukeka"</string>
    <string name="category_name_color" msgid="937514550918977151">"Umbala"</string>
    <string name="category_name_display_controls" msgid="7046581691184725216">"Ezinye izilawul zesibonisi"</string>
    <string name="category_name_general" msgid="7737273712848115886">"Okuvamile"</string>
    <string name="dark_theme_main_switch_title" msgid="4045147031947562280">"Sebenzisa itimu emnyama"</string>
    <string name="bluetooth_main_switch_title" msgid="8409835540311309632">"Sebenzisa i-Bluetooth"</string>
    <string name="prevent_ringing_main_switch_title" msgid="4726252811262086643">"Sebenzisa ukugwema ukukhalisa"</string>
    <string name="use_wifi_hotsopt_main_switch_title" msgid="3909731167290690539">"Sebenzisa i-Wi‑Fi hotspot"</string>
    <string name="app_pinning_main_switch_title" msgid="5465506660064032876">"Sebenzisa ukuphina i-app"</string>
    <string name="developer_options_main_switch_title" msgid="1720074589554152501">"Sebenzisa izinkinobho zikanjiniyela"</string>
    <string name="default_print_service_main_switch_title" msgid="4697133737128324036">"Sebenzisa isevisi yokuphrinta"</string>
    <string name="multiple_users_main_switch_title" msgid="6686858308083037810">"Vumela abasebenzisi abaningi"</string>
    <string name="multiple_users_main_switch_keywords" msgid="4845954458094134356">"vumela, eziningi, umsebenzisi, vumela, eziningi"</string>
    <string name="wireless_debugging_main_switch_title" msgid="8463499572781441719">"Sebenzisa ukususa ibhagi nge-Wi-Fi"</string>
    <string name="graphics_driver_main_switch_title" msgid="6125172901855813790">"Sebenzisa okuncanyelwayo kwesishayeli sokuyingcaca"</string>
    <string name="night_light_main_switch_title" msgid="3428298022467805219">"Sebenzisa Ukukhanya kwasebusuku"</string>
    <string name="nfc_main_switch_title" msgid="6295839988954817432">"Sebenzisa i-NFC"</string>
    <string name="adaptive_brightness_main_switch_title" msgid="2681666805191642737">"Sebenzisa ukukhanya okuguqukayo"</string>
    <string name="wifi_calling_main_switch_title" msgid="4070224008346815634">"Sebenzisa ukushaya kwe-Wi‑Fi"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Bona zonke izinhlelo zokusebenza"</string>
    <string name="smart_forwarding_title" msgid="8368634861971949799">"Ukudluliselwa phambili okuhlakaniphile"</string>
    <string name="smart_forwarding_summary_enabled" msgid="3341062878373185604">"Ukudlulisela phambili okusmathi kunikwe amandla"</string>
    <string name="smart_forwarding_summary_disabled" msgid="5033880700091914809">"Ukudlulisela phambili okusmathi kukhutshaziwe"</string>
    <string name="smart_forwarding_ongoing_title" msgid="962226849074401228">"Izilungiselelo zekholi"</string>
    <string name="smart_forwarding_ongoing_text" msgid="2189209372407117114">"Ibuyekeza amasethingi…"</string>
    <string name="smart_forwarding_failed_title" msgid="1859891191023516080">"Iphutha lamasethingi wekholi"</string>
    <string name="smart_forwarding_failed_text" msgid="8682640643264071789">"Iphutha lenethiwekhi noma le-SIM."</string>
    <string name="smart_forwarding_failed_not_activated_text" msgid="997396203001257904">"I-Sim ayenziwanga yasebenza."</string>
    <string name="smart_forwarding_input_mdn_title" msgid="5105463748849841763">"Faka izinombolo zefoni"</string>
    <string name="smart_forwarding_input_mdn_dialog_title" msgid="7542216086697868415">"Faka inombolo yefoni"</string>
    <string name="smart_forwarding_missing_mdn_text" msgid="2907314684242542226">"Inombolo yefoni ayikho."</string>
    <string name="smart_forwarding_missing_alert_dialog_text" msgid="7870419247987316112">"KULUNGILE"</string>
    <string name="enable_2g_title" msgid="8184757884636162942">"Vumela i-2G"</string>
    <string name="enable_2g_summary" msgid="2794534052372565914">"I-2G ivikeleke kancane, kodwa ingase ithuthukise ukuxhumeka kwakho kwezinye izindawo. Mayelana namakholi aphuthumayo, i-2G ihlala njalo ivunyelwe."</string>
    <string name="enable_2g_summary_disabled_carrier" msgid="8141118453219482762">"I-<xliff:g id="CARRIER_NAME_2G">%1$s</xliff:g> idinga i-2G ibe khona"</string>
    <string name="require_cellular_encryption_title" msgid="7516008146269371585">"Udinga ukubethela"</string>
    <string name="require_cellular_encryption_summary" msgid="4813823321032908641">"Ukubethela kuvikeleke kakhulu, kodwa ungase ungakwazi ukuxhuma kwezinye izindawo. Kumakholi aphuthumayo, ukubethela akudingekile"</string>
    <string name="app_info_all_services_label" msgid="1487070364839071105">"Amasevisi wonke"</string>
    <string name="show_clip_access_notification" msgid="7782300987639778542">"Bonisa ukufinyelela kubhodi yokunamathisela"</string>
    <string name="show_clip_access_notification_summary" msgid="474090757777203207">"Bonisa umlayezo uma ama-app wakho afinyelela umbhalo, izithombe, noma okunye okuqukethwe okukopishile"</string>
    <string name="all_apps" msgid="3054120149509114789">"Wonke ama-app"</string>
    <string name="request_manage_bluetooth_permission_dont_allow" msgid="8798061333407581300">"Ungavumeli"</string>
    <string name="uwb_settings_title" msgid="8578498712312002231">"I-Ultra-WideBand (UWB)"</string>
    <string name="uwb_settings_summary" msgid="3074271396764672268">"Isiza ukukhomba ukuma okuhlobene kwamadivayisi aseduze ane-UWB"</string>
    <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Vala imodi yendiza ukuze usebenzise i-UWB"</string>
    <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"I-UWB ayitholakali endaweni yamanje"</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">"Ukufinyelela kwekhamera"</string>
    <string name="mic_toggle_title" msgid="265145278323852547">"Ukufinyelela kwemakrofoni"</string>
    <string name="perm_toggle_description" msgid="5754629581767319022">"Okwama-app namasevisi"</string>
    <string name="mic_toggle_description" msgid="484139688645092237">"Okwama-app namasevisi. Uma leli sethingi livaliwe, idatha yemakrofoni ingabiwa uma ushayela inombolo yezimo eziphuthumayo."</string>
    <string name="previous_page_content_description" msgid="6438292457923282991">"Okwangaphambilini"</string>
    <string name="next_page_content_description" msgid="1641835099813416294">"Okulandelayo"</string>
    <string name="colors_viewpager_content_description" msgid="2591751086138259565">"Ukubuka kuqala umbala"</string>
    <string name="bluetooth_sim_card_access_notification_title" msgid="7351015416346359536">"Isicelo sokufinyelela ku-SIM"</string>
    <string name="bluetooth_sim_card_access_notification_content" msgid="8685623260103018309">"Idivayisi ifuna ukufinyelela ku-SIM yakho. Thepha ukuze uthole imininingwane"</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="5616323725563125179">"Vumela ukufinyelela ku-SIM?"</string>
    <string name="bluetooth_sim_card_access_dialog_content" msgid="6281997628405909566">"Idivayisi ye-Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, ifuna ukufinyelela idatha kusuka ku-SIM yakho. Lokhu kubandakanya oxhumana nabo.\n\nNgenkathi uxhumekile, i-<xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> izithola wonke amakholi enziwa ku-<xliff:g id="PHONE_NUMBER">%3$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_notification_title" msgid="2573547043170883947">"Idivayisi ye-Bluetooth iyatholakala"</string>
    <string name="bluetooth_connect_access_notification_content" msgid="1328465545685433304">"Idivayisi ifuna ukuxhuma. Thepha ukuze uthole imininingwane"</string>
    <string name="bluetooth_connect_access_dialog_title" msgid="1948056782712451381">"Xhuma kwidivaysi ye-Bluetooth?"</string>
    <string name="bluetooth_connect_access_dialog_content" msgid="4336436466468405850">"I-<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> ifuna ukuxhuma kule foni.\n\nAwuxhumile ku-<xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> ngaphambilini."</string>
    <string name="bluetooth_connect_access_dialog_negative" msgid="4944672755226375059">"Ungaxhumi"</string>
    <string name="bluetooth_connect_access_dialog_positive" msgid="3630561675207269710">"Xhuma"</string>
    <string name="tare_settings" msgid="3788654800004869077">"Amasethingi we-TARE"</string>
    <string name="tare_on" msgid="2386073225978684535">"Vuliwe"</string>
    <string name="tare_off" msgid="6305694402929756726">"Valiwe"</string>
    <string name="tare_revert" msgid="3855325741125236638">"Buyela Kumasethingi Wokuzenzakalelayo"</string>
    <string name="tare_settings_reverted_toast" msgid="8189887409285176731">"Amasethingi abuyiselwe kokuzenzakalelayo."</string>
    <string name="tare_max_satiated_balance" msgid="3914973999573150340">"Ibhalansi Egculisiwe Ephezulu"</string>
    <string name="tare_balances" msgid="731881382594747961">"Amabhalansi"</string>
    <string name="tare_consumption_limits" msgid="3230949387874396382">"Ukusetshenziswa Kwemikhawulo"</string>
    <string name="tare_initial_consumption_limit" msgid="2921646306374048384">"Umkhawulo Wokusebenzisa Wokuqala"</string>
    <string name="tare_min_consumption_limit" msgid="3293145670921755789">"Umkhawulo Wokusebenzisa Ophansi"</string>
    <string name="tare_max_consumption_limit" msgid="8335700580111808823">"Umkhawulo Wokusebenzisa Omkhulu"</string>
    <string name="tare_modifiers" msgid="8919975635360280820">"Abashintshi"</string>
    <string name="tare_actions_ctp" msgid="5110104015354916401">"Izenzo (Izindleko Zokukhiqiza)"</string>
    <string name="tare_actions_base_price" msgid="3300967942666376589">"Izenzo (Intengo Eyisisekelo)"</string>
    <string name="tare_rewards_instantaneous" msgid="8358683519945340874">"Imiklomelo yomcimbi ngamunye"</string>
    <string name="tare_rewards_ongoing" msgid="7657030286658143416">"Imiklomelo ngomzuzwana ngamunye wobude bomcimbi"</string>
    <string name="tare_rewards_max" msgid="5283055625642837010">"Imiklomelo Ephezulu Ngosuku"</string>
    <string name="tare_app_install" msgid="7955806910408116882">"Ukufaka i-App"</string>
    <string name="tare_top_activity" msgid="7266560655483385757">"Umsebenzi Ophezulu"</string>
    <string name="tare_notification_seen" msgid="7829963536020087742">"Isaziso Siboniwe"</string>
    <string name="tare_notification_seen_15_min" msgid="832174185809497764">"Isaziso Sibonwe Phakathi Nemizuzu eyi-15"</string>
    <string name="tare_notification_interaction" msgid="3806204222322830129">"Ukusebenzisana Kwesaziso"</string>
    <string name="tare_widget_interaction" msgid="2260701564089214184">"Ukusebenzisana Kwewijethi"</string>
    <string name="tare_other_interaction" msgid="8069163421115212751">"Okunye Ukusebenzisana Komsebenzisi"</string>
    <string name="tare_job_max_start" msgid="1586399578665940836">"Ukuqala Komsebenzi Okuphezulu"</string>
    <string name="tare_job_max_running" msgid="2897217372986518495">"Ukusebenza Okuphezulu Komsebenzi"</string>
    <string name="tare_job_high_start" msgid="7464143754932031022">"Ukuqala Okuphezulu Komsebenzi"</string>
    <string name="tare_job_high_running" msgid="6541171046405088669">"Ukusebenza Okuphezulu Komsebenzi"</string>
    <string name="tare_job_default_start" msgid="6744427210148953151">"Ukuqala Okuzenzekelayo Komsebenzi"</string>
    <string name="tare_job_default_running" msgid="8429081804128945217">"Ukusebenza Okuzenzekelayo Komsebenzi"</string>
    <string name="tare_job_low_start" msgid="4605440035856891746">"Ukuqala Okuphansi Komsebenzi"</string>
    <string name="tare_job_low_running" msgid="831668616902849604">"Ukusebenza Komsebenzi Okuphansi"</string>
    <string name="tare_job_min_start" msgid="6508233901992538188">"Ukuqala Komsebenzi Okuphansi"</string>
    <string name="tare_job_min_running" msgid="6167128996320622604">"Ukusebenza Komsebenzi Okuphansi"</string>
    <string name="tare_job_timeout_penalty" msgid="7644332836795492506">"Inhlawulo Yesikhathi Sokuvala Umsebenzi"</string>
    <string name="tare_min_balance_exempted" msgid="6693710075762973485">"Ibhalansi Enelisekile (Ikhululiwe)"</string>
    <string name="tare_min_balance_headless_app" msgid="6906353766678577244">"Ibhalansi Enelisekile (I-App Yesistimu Engenazinhloko)"</string>
    <string name="tare_min_balance_other_app" msgid="3404774196832506476">"Ibhalansi Enelisekile (Ama-app Asele)"</string>
    <string name="tare_min_balance_addition_app_updater" msgid="5391956072471201269">"Ukwengezwa Kwebhalansi Egcwalisiwe Encane (Izibuyekezi ze-App)"</string>
  <string-array name="tare_modifiers_subfactors">
    <item msgid="3325940509857535498">"Iyashaja"</item>
    <item msgid="658627268149681677">"Ukozela"</item>
    <item msgid="1599558140284643834">"Imodi Yokonga Amandla"</item>
    <item msgid="588427840913221601">"Isimo Sokucubungula"</item>
  </string-array>
    <string name="tare_dialog_confirm_button_title" msgid="9179397559760203348">"Qinisekisa"</string>
    <string name="dream_preview_button_title" msgid="6637456541851795952">"Hlola kuqala"</string>
    <string name="dream_picker_category" msgid="7726447836872744867">"Khetha isilondolozi sesikrini"</string>
    <string name="dream_complications_toggle_title" msgid="4273232303027449163">"Bonisa ulwazi olwengeziwe"</string>
    <string name="dream_complications_toggle_summary" msgid="8088911054987524904">"Bonisa izinto ezifana nesikhathi, isimo sezulu, noma olunye ulwazi kusilondolozi sesikrini"</string>
    <string name="dream_home_controls_toggle_title" msgid="706799741564479248">"Bonisa izilawuli zasekhaya"</string>
    <string name="dream_home_controls_toggle_summary" msgid="4102519907917430579">"Bonisa inkinobho yezilawuli zasekhaya kusukela kusilondolozi sesikrini"</string>
    <string name="dream_more_settings_category" msgid="3119192146760773748">"Amasethingi amaningi"</string>
    <string name="dream_setup_title" msgid="2458303874255396142">"Khetha isilondolozi sakho sesikrini"</string>
    <string name="dream_setup_description" msgid="7508547154038580296">"Khetha ozokubona esikrinini sakho uma ithebulethi yakho idokhiwe. Idivayisi yakho ingase isebenzise amandla engeziwe uma kusetshenziswa isilondolozi sesikrini."</string>
    <string name="customize_button_title" msgid="1110284655990203359">"Enza ngendlela oyifisayo"</string>
    <string name="customize_button_description" msgid="7440248477266126231">"Enza ngendlela oyifisayo <xliff:g id="SCREENSAVER_NAME">%1$s</xliff:g>"</string>
    <string name="reboot_dialog_enable_freeform_support" msgid="6412591361284929149">"Ukuqalisa kabusha kuyadingeka ukunika amandla usekelo lwefomu yamahhala."</string>
    <string name="reboot_dialog_force_desktop_mode" msgid="2021839270403432948">"Ukuqalisa kabusha kuyadingeka ukuphoqelela imodi yedeskithophu kuzibonisi zesibili."</string>
    <string name="reboot_dialog_reboot_now" msgid="235616015988522355">"Qalisa manje"</string>
    <string name="reboot_dialog_reboot_later" msgid="4261717094186904568">"Qalisa ngokuhamba kwesikhathi"</string>
    <string name="bluetooth_details_spatial_audio_title" msgid="1368071116994002707">"Umsindo Wokulalelwayo"</string>
    <string name="bluetooth_details_spatial_audio_summary" msgid="5026859623681482668">"Umsindo ovela kumidiya ehambisanayo uba ogxile kakhulu"</string>
    <string name="bluetooth_details_head_tracking_title" msgid="5416972521040337799">"Ukulandelela ikhanda"</string>
    <string name="bluetooth_details_head_tracking_summary" msgid="3942238746595985395">"Umsindo uyashintsha njengoba uhambisa ikhanda lakho ukuze lizwakale ngokwemvelo"</string>
    <string name="bluetooth_details_permissions_sync_title" msgid="7277580382321003521">"Vumelanisa izimvume ezivele efonini yakho"</string>
    <string name="bluetooth_details_permissions_sync_summary" msgid="8125037984381432059">"Nikeza iwashi lakho izimvume ezifanayo ze-app ozivumele kulefoni"</string>
    <string name="bluetooth_details_audio_device_types_title" msgid="3381941189346781614">"Uhlobo Lwedivayisi Yokulalelwayo"</string>
    <string name="bluetooth_details_audio_device_type_unknown" msgid="839337391037998014">"Akwaziwa"</string>
    <string name="bluetooth_details_audio_device_type_speaker" msgid="3706227767994792124">"Isipikha"</string>
    <string name="bluetooth_details_audio_device_type_headphones" msgid="7644588291215033798">"Ama-headphone"</string>
    <string name="bluetooth_details_audio_device_type_hearing_aid" msgid="1310631131071939859">"Usizo Lokuzwa"</string>
    <string name="bluetooth_details_audio_device_type_carkit" msgid="4439017600454703229">"Ikhithi Yemoto"</string>
    <string name="bluetooth_details_audio_device_type_other" msgid="7019481234617207563">"Okunye"</string>
    <string name="ingress_rate_limit_title" msgid="2106694002836274350">"Umkhawulo wesilinganiso sokudawuniloda kwenethiwekhi"</string>
    <string name="ingress_rate_limit_summary" msgid="1097811019742438371">"Lungiselela umkhawulo wezinga lokungena komkhawulokudonsa wenethiwekhi osetshenziswa kuwo wonke amanethiwekhi ahlinzeka ngoxhumano lwe-inthanethi."</string>
    <string name="ingress_rate_limit_dialog_title" msgid="5359461052422633789">"Lungiselela umkhawulo wesilinganiso sokudawuniloda kwenethiwekhi"</string>
    <string name="ingress_rate_limit_no_limit_entry" msgid="8741098826008012163">"Awukho umkhawulo"</string>
    <string name="disable_phantom_process_monitor_title" msgid="8348108346706188771">"Khubaza imikhawulo yenqubo yengane"</string>
    <string name="disable_phantom_process_monitor_summary" msgid="3044464635550256985">"Khubaza imikhawulo ekusetshenzisweni kwensiza yesistimu yezinqubo zezingane ze-app"</string>
    <string name="enable_notes_role_title" msgid="7662702013496114763">"Phoqa ukunika amandla indima yamanothi"</string>
    <string name="enable_notes_role_summary" msgid="5495721409392395089">"Nika amandla ukuhlanganiswa kwesistimu yokuthatha amanothi ngendima Yamanothi. Uma indima Yamanothi isivele inikwe amandla, ayenzi lutho. Kudinga ukuqalisa."</string>
    <string name="bluetooth_broadcast_dialog_title" msgid="9172775308463135884">"Sakaza"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_app" msgid="1016617579194329005">"Sakaza i-<xliff:g id="CURRENTAPP">%1$s</xliff:g>"</string>
    <string name="bluetooth_broadcast_dialog_find_message" msgid="6621660851669953883">"Lalela ukusakaza okuseduze kwakho"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_message" msgid="6198264676009094495">"Sakaza imidiya kumadivayisi aseduze kwakho, noma ulalele ukusakaza komunye umuntu"</string>
    <string name="bluetooth_find_broadcast_title" msgid="5385985218699831970">"Ukusakaza"</string>
    <string name="bluetooth_find_broadcast_summary" msgid="3907899428626210673">"Ulalele"</string>
    <string name="bluetooth_find_broadcast" msgid="1768337775649457586">"Thola ukusakaza"</string>
    <string name="bluetooth_find_broadcast_button_leave" msgid="7881206581147104908">"Shiya ukusakaza"</string>
    <string name="bluetooth_find_broadcast_button_scan" msgid="3995664694641895189">"Skena ikhodi ye-QR"</string>
    <string name="find_broadcast_password_dialog_title" msgid="3176988702535737484">"Faka iphasiwedi"</string>
    <string name="find_broadcast_password_dialog_connection_error" msgid="47873617983439400">"Ayikwazi ukuxhuma. Zama futhi."</string>
    <string name="find_broadcast_password_dialog_password_error" msgid="243855327674765">"Iphasiwedi engalungile"</string>
    <string name="find_broadcast_join_broadcast_error" msgid="5486980388774711346">"Awukwazi ukujoyina ukusakaza"</string>
    <string name="bt_le_audio_scan_qr_code_scanner" msgid="7614569515419813053">"Ukuze uqale ukulalela, beka ikhodi ye-QR ngezansi"</string>
    <string name="bt_le_audio_qr_code_is_not_valid_format" msgid="7821837654128137901">"Ikhodi ye-QR ayiyona ifomethi evumelekile"</string>
    <string name="convert_to_esim_title" msgid="71037864129009206">"Shintshela ku-eSIM"</string>
    <string name="transfer_esim_to_another_device_title" msgid="5286117866086383192">"Dlulisela i-eSIM kwenye idivayisi"</string>
    <string name="background_install_preference_summary" msgid="3065219346519340364">"{count,plural, =1{i-app e-#}one{ama-app angu-#}other{ama-app angu-#}}"</string>
    <string name="background_install_title" msgid="607913515188276168">"Ama-app afakwe ngemuva"</string>
    <string name="background_install_summary" msgid="3890296129543309666">"Umkhiqizi wedivayisi yakho angase afake ama-app kudivayisi yakho ngemuva, noma avumele inkampani yakho yenethiwekhi nabanye ozakwethu ukuthi benze kanjalo.\n\nNoma yimaphi ama-app asohlwini lapha awadingeki ukuze idivayisi yakho isebenze ngokujwayelekile. Ungakhipha ama-app ongawafuni."</string>
    <string name="background_install_feature_list_no_entry" msgid="2071343281272266154">"Awekho ama-app afakiwe ngemuva"</string>
    <string name="background_install_uninstall_button_description" msgid="1189649052911501249">"Khipha i-app"</string>
    <string name="background_install_before" msgid="8608614957688912715">"{count,plural, =1{Ama-app afakwe enyangeni e-# edlule}one{Ama-app afakwe ezinyangeni ezingu-# ezedlule}other{Ama-app afakwe ezinyangeni ezingu-# ezedlule}}"</string>
    <string name="background_install_after" msgid="7983488897570908149">"{count,plural, =1{Ama-app afakwe ngaphezu kwenyanga e-# edlule}one{Ama-app afakwe ngaphezu kwezinyanga ezingu-# ezidlule}other{Ama-app afakwe ngaphezu kwezinyanga ezingu-# ezidlule}}"</string>
    <string name="aspect_ratio_title" msgid="2451826875939676101">"Ukubukeka kwesilinganiselo"</string>
    <string name="aspect_ratio_summary" msgid="4056406351663726494">"Zama ukubukeka kwesilinganiselo okusha ukuze ubuke le app ukuthi ayenzelwe yini ukungena ku-<xliff:g id="DEVICE_NAME">%1$s</xliff:g> yakho"</string>
    <string name="aspect_ratio_main_summary" msgid="4141964559612756940">"Zama ukubukeka kwesilinganiselo okusha ukuze ubuke le app ukuthi ayenzelwe yini ukungena ku-<xliff:g id="DEVICE_NAME">%1$s</xliff:g> yakho. Amanye ama-app kungenzeka angalungiselelwa ukubukeka kwesilinganiselo okuthile."</string>
    <string name="aspect_ratio_summary_text" msgid="4737461467467220325">"Zama ukubukeka kwesilinganiselo okusha ukuze ubuke i-app ukuthi ayenzelwe yini ukungena ku-<xliff:g id="DEVICE_NAME">%1$s</xliff:g> yakho"</string>
    <string name="aspect_ratio_main_summary_text" msgid="5544816872094235840">"Zama ukubukeka kwesilinganiselo okusha ukuze ubuke i-app ukuthi ayenzelwe yini ukungena ku-<xliff:g id="DEVICE_NAME">%1$s</xliff:g> yakho. Amanye ama-app kungenzeka angalungiselelwa ukubukeka kwesilinganiselo okuthile."</string>
    <string name="user_aspect_ratio_suggested_apps_label" msgid="8085934042329632039">"Ama-app aphakanyisiwe"</string>
    <string name="user_aspect_ratio_changed_apps_label" msgid="2096614916172567672">"Ama-app ashintshiwe"</string>
    <string name="user_aspect_ratio_app_default" msgid="270065763307617837">"Okuzenzakalelayo kwe-app"</string>
    <string name="user_aspect_ratio_fullscreen" msgid="1843427242540081996">"Iskrini esigcwele"</string>
    <string name="user_aspect_ratio_half_screen" msgid="1015852057094310209">"Isikrini esiwuhhafu"</string>
    <string name="user_aspect_ratio_device_size" msgid="2339820985120881199">"Ukubukeka kwedivayisi"</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">"I-<xliff:g id="NUMERATOR">%1$s</xliff:g> ka-<xliff:g id="DENOMINATOR">%2$s</xliff:g>"</string>
    <string name="app_aspect_ratio_footer" msgid="4029509301182067475">"I-app izoqala kabusha uma ushintsha ukubukeka kwesilinganiselo. Ungase ulahlekelwe yizinguquko ezingalondoloziwe. Amanye ama-app kungenzeka angalungiselelwa ukubukeka kwesilinganiselo okuthile."</string>
    <string name="aspect_ratio_experimental_title" msgid="9088785421062044831">"Ukubukeka kwesilinganiselo (okuhlolwayo)"</string>
    <string name="aspect_ratio_experiment_title" msgid="128614319422121040">"Ukubukeka kwesilinganiselo (ukuhlola)"</string>
    <string name="aspect_ratio_labs_title" msgid="6733893837442759383">"Ukubukeka kwesilinganiselo (amalebhu)"</string>
    <string name="aspect_ratio_experimental_label" msgid="6319009297672567578">"Okuhlolwayo"</string>
    <string name="aspect_ratio_experiment_label" msgid="7861871612376167784">"Ukuhlola"</string>
    <string name="aspect_ratio_labs_label" msgid="7008498116297651342">"Amalebhu"</string>
    <string name="accessibility_fingerprint_label" msgid="5017431423168191733">"Inzwa yesigxivizo somunwe"</string>
    <string name="flash_notifications_title" msgid="4490438861180492311">"Izaziso zokukhanya"</string>
    <string name="flash_notifications_about_title" msgid="9004351252928121214">"Mayelana nezaziso ze-flash"</string>
    <string name="flash_notifications_summary_off" msgid="6056282996770691461">"Valiwe"</string>
    <string name="flash_notifications_summary_on_camera" msgid="3286405833586333730">"Ivuliwe / ukukhanya kwekhamera"</string>
    <string name="flash_notifications_summary_on_screen" msgid="9040640799633336219">"Ivuliwe / ukukhanya kwesikrini"</string>
    <string name="flash_notifications_summary_on_camera_and_screen" msgid="2326268141063768701">"Ivuliwe / ikhamera nokukhanya kwesikrini"</string>
    <string name="flash_notifications_intro" msgid="8409873413480928249">"Khanysa i-flash ukukhanya kwekhamera noma isikrini uma uthola izaziso noma uma ama-alamu ekhala."</string>
    <string name="flash_notifications_intro_without_camera_flash" msgid="6297337174487793891">"Khanyisa isikrini uma uthola izaziso noma uma kukhala ama-alamu"</string>
    <string name="flash_notifications_note" msgid="2426125248448055075">"Sebenzisa izaziso ze-flash ngokucophelela uma uzwela ukukhanya"</string>
    <string name="flash_notifications_keywords" msgid="2458759275318514836">"i-flash, ukukhanya, onenkinga yokuzwa, ukulahlekelwa ukuzwa"</string>
    <string name="flash_notifications_preview" msgid="5320176885050440874">"Hlola kuqala"</string>
    <string name="camera_flash_notification_title" msgid="2475084876382922732">"I-flash yekhamela"</string>
    <string name="screen_flash_notification_title" msgid="3773100725793316708">"Ukukhanya kwesikrini"</string>
    <string name="screen_flash_notification_color_title" msgid="7213407653340970790">"Umbala wokukhanya kwesikrini"</string>
    <string name="screen_flash_color_blue" msgid="3585766657607931371">"Okuluhlaza okwesibhakabhaka"</string>
    <string name="screen_flash_color_azure" msgid="8691198532944992243">"I-Azure"</string>
    <string name="screen_flash_color_cyan" msgid="6878780006173747267">"I-Cyan"</string>
    <string name="screen_flash_color_spring_green" msgid="4466548514738457815">"I-Spring esiluhlaza okotshani"</string>
    <string name="screen_flash_color_green" msgid="8418019648507964564">"Okuluhlaza okotshani"</string>
    <string name="screen_flash_color_chartreuse_green" msgid="7456381649919010366">"I-Chartreuse eluhlaza okotshani"</string>
    <string name="screen_flash_color_yellow" msgid="7413465411615454556">"Okuphuzi"</string>
    <string name="screen_flash_color_orange" msgid="979177126315557656">"Olintshi"</string>
    <string name="screen_flash_color_red" msgid="8954162219886445491">"Okubomvu"</string>
    <string name="screen_flash_color_rose" msgid="1216848195972231251">"Imbali"</string>
    <string name="screen_flash_color_magenta" msgid="7726221666557102155">"I-Magenta"</string>
    <string name="screen_flash_color_violet" msgid="1279950780509029495">"I-Violet"</string>
    <string name="color_selector_dialog_done" msgid="121253968943363376">"Kwenziwe"</string>
    <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Khansela"</string>
    <string name="contrast_title" msgid="6885768151336508075">"Ukugqama"</string>
    <string name="contrast_standard" msgid="1097297089917185235">"Okujwayelekile"</string>
    <!-- no translation found for contrast_default (8918545965525226966) -->
    <skip />
    <string name="contrast_medium" msgid="384414510709285811">"Okuphakathi"</string>
    <string name="contrast_high" msgid="3988567609694797696">"Phezulu"</string>
    <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Le-app ingavulwa kuphela ewindini eli-1."</string>
    <string name="generic_accessibility_service_on" msgid="4466229372357726824">"Ivuliwe"</string>
    <string name="generic_accessibility_service_off" msgid="4759859497651675724">"Ivaliwe"</string>
    <string name="generic_accessibility_feature_shortcut_off" msgid="4022872394514077907">"Ivaliwe"</string>
    <string name="accessibility_shortcut_state_off" msgid="8158137799007601475">"Valiwe"</string>
    <string name="daltonizer_state_on" msgid="131013270022603983">"Vuliwe"</string>
    <string name="daltonizer_state_off" msgid="1162285688069856179">"Valiwe"</string>
    <string name="color_inversion_state_on" msgid="1160969033636440368">"Vuliwe"</string>
    <string name="color_inversion_state_off" msgid="6925638668080451724">"Valiwe"</string>
    <string name="color_inversion_feature_summary" msgid="1199876648549627647">"Ishintsha izikrini ezikhanyayo zibe mnyama nezikrini ezimnyama zikhanye"</string>
    <string name="magnification_feature_summary" msgid="2053971569640663564">"Sondeza isithombe esikrinini"</string>
    <string name="autoclick_disabled" msgid="3213396804955002120">"Valiwe"</string>
    <string name="show_captions_disabled" msgid="690650956523818755">"Valiwe"</string>
    <string name="show_captions_enabled" msgid="7089043007924626">"Vuliwe"</string>
    <string name="live_caption_disabled" msgid="3562035026547887366">"Valiwe"</string>
    <string name="live_caption_enabled" msgid="5269360946200718949">"Vuliwe"</string>
    <string name="about_phone_device_name_warning" msgid="3243226572404472381">"Igama ledivayisi yakho liyabonakala kuma-app owafakile. Lingase futhi libonwe ngabanye abantu lapho uxhuma kumadivayisi e-Bluetooth, uxhuma kunethiwekhi ye-Wi-Fi noma usetha i-hotspot ye-Wi-Fi."</string>
    <string name="grammatical_gender_title" msgid="8584242850477270828">"Ubulili bohlelo lolimi"</string>
    <string name="grammatical_gender_dialog_title" msgid="8754048592099871587">"Khetha ubulili Bohlelo lolimi"</string>
    <string name="content_protection_preference_title" msgid="5069260032659193074">"Iskena ukuze ithole ama-app akhohlisayo"</string>
    <string name="content_protection_preference_summary" msgid="2252393849408445391">"Hlola umsebenzi we-app wobugebengu bokweba imininingwane ebucayi"</string>
    <string name="content_protection_preference_user_consent_switch_title" msgid="1797782616799594426">"Sebenzisa ukuskena ama-app akhohlisayo"</string>
    <string name="content_protection_preference_user_consent_work_profile_switch_title" msgid="3004347470520916069">"Sebenzisa ukuskena ama-app akhohlisayo omsebenzi"</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">"Iphasiwe manje isethiwe"</string>
    <string name="show_stylus_pointer_icon" msgid="1010583689203665786">"Bonisa isikhombi ngenkathi uhambisa phezulu"</string>
</resources>
