<?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">"Ndiyo"</string>
    <string name="no" msgid="5541738710521607130">"Hapana"</string>
    <string name="create" msgid="986997212165228751">"Unda"</string>
    <string name="allow" msgid="3763244945363657722">"Ruhusu"</string>
    <string name="deny" msgid="7326117222944479942">"Kataa"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Washa"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Haijulikani"</string>
    <string name="device_info_protected_single_press" msgid="3810785480060743677">"Gusa ili uone maelezo"</string>
    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{Sasa umebakisha hatua # ili uwe msanidi programu.}other{Sasa umebakisha hatua # ili uwe msanidi programu.}}"</string>
    <string name="show_dev_on" msgid="2840850085134853754">"Sasa wewe ni msanidi programu!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Hakuna haja, tayari wewe ni msanidi programu."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Tafadhali washa chaguo za wasanidi programu kwanza."</string>
    <string name="dev_settings_available_to_admin_only_warning" msgid="3408243404879083111">"Ni watumiaji wasimamizi pekee wanaoweza kufikia mipangilio ya msanidi programu."</string>
    <string name="header_category_system" msgid="1665516346845259058">"Mfumo"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"Inatumika"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Haitumiki"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Radio Imezimwa"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Unatumia mitandao ya ng\'ambo"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Hautumii mitandao ya ng\'ambo"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Haijaunganishwa"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Inaunganisha"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Umeunganishwa"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Imetanguliwa"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Haijulikani"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Kagua kwanza"</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Punguza"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Kuza"</string>
    <string name="stay_awake_on_fold_title" msgid="6590454679898134221">"Kila wakati"</string>
    <string name="stay_awake_on_fold_summary" msgid="1939963751585954262">"Skrini ya mbele huwaka unapokunja kifaa chako"</string>
    <string name="selective_stay_awake_title" msgid="7887645333447645168">"Video na michezo pekee na zaidi"</string>
    <string name="selective_stay_awake_summary" msgid="9055967322921984543">"Skrini ya mbele huwaka unapofungua programu zinazozuia skrini yako kujizima"</string>
    <string name="stay_awake_on_lockscreen_title" msgid="8088456642083051068">"Telezesha kidole juu ili uendelee"</string>
    <string name="stay_awake_on_lockscreen_summary" msgid="2299351813382522952">"Kunja simu yako kisha utelezeshe kidole juu kwenye mwonekano wa mbele ili uendelee kutumia programu, au subiri sekunde chache ili skrini ifungwe"</string>
    <string name="sleep_on_fold_title" msgid="7626123024330501411">"Kamwe"</string>
    <string name="sleep_on_fold_summary" msgid="7737992842459588846">"Skrini ya mbele hufungwa unapokunja kifaa chako"</string>
    <string name="auto_rotate_settings_primary_switch_title" msgid="3440951924928594520">"Ruhusu skrini ijizungushe kiotomatiki"</string>
    <string name="smart_rotate_text_headline" msgid="5878008933992951904">"Kipengele cha Utambuzi wa Nyuso hutumia kamera ya mbele ili kuboresha usahihi wa kuzungusha skrini kiotomatiki. Picha hazihifadhiwi wala kutumwa kwa Google."</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Inaonekana kwa zote zilizokaribu na vifaa vya Bluetooth (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Inaonekana kwa zote zilizokaribu na vifaa vya Bluetooth"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Haionekani na vifaa vingine vyenye Bluetooth"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Inaonekana na vifaa vilivyooanishwa pekee"</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Vifaa vya Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Jina la kifaa"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Badilisha jina la kifaa hiki"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Hifadhi jina jipya"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Ungependa kuondoa kifaa?"</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Unganisha kifaa kipya"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"bluetooth"</string>
    <string name="bluetooth_screen_auto_on_title" msgid="8496443490064988240">"Iwashe tena kesho kiotomatiki"</string>
    <string name="bluetooth_pair_right_ear_button" msgid="3979894494803078852">"Unganisha kisaidizi cha kulia"</string>
    <string name="bluetooth_pair_left_ear_button" msgid="1019938875726073791">"Unganisha kisaidizi cha kushoto"</string>
    <string name="bluetooth_pair_other_ear_dialog_title" msgid="3814943511999984012">"Unganisha kisaidizi cha sikio jingine"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_message" msgid="5711642363615781647">"Kifaa chako cha kusikilizia cha kushoto kimeunganishwa.\n\nIli uoanishe cha kulia, hakikisha kuwa kimewashwa na kipo tayari kuoanishwa."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message" msgid="631521133525979967">"Kifaa chako cha kusikilizia cha kulia kimeunganishwa.\n\nIli uoanishe cha kushoto, hakikisha kuwa kimewashwa na kipo tayari kuoanishwa."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Unganisha kisaidizi cha kulia"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Unganisha kisaidizi cha kushoto"</string>
    <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Kwa vifaa vyote vya kusikia vinavyopatikana"</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">"Katika kifaa hiki"</string>
    <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Vifaa vya kutoa sauti"</string>
    <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Kuhusu vifaa vya kutoa sauti"</string>
    <string name="bluetooth_audio_routing_summary" msgid="7180947533985969066">"Elekeza sauti kwenye kifaa chako cha kusikia au spika ya simu"</string>
    <string name="bluetooth_screen_related" msgid="7976543255501825536">"Zinazofanana"</string>
    <string name="bluetooth_ringtone_title" msgid="3177308461256892085">"Milio ya simu na kengele"</string>
    <string name="bluetooth_call_title" msgid="6851464952021874072">"Sauti wakati wa simu"</string>
    <string name="bluetooth_media_title" msgid="2878373577382067290">"Sauti za maudhui na mfumo"</string>
    <string name="bluetooth_notification_title" msgid="8708962394926222039">"Arifa"</string>
    <string name="bluetooth_audio_routing_footer_summary" msgid="410260713589309293">"Kwa chaguomsingi, sauti inayotoka hubainishwa na programu mahususi"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Kifaa cha Bluetooth kisicho na jina"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Inatafuta"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"Hakuna vifaa vya Bluetooth vilivyopatikana karibu."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Ombi la kuoanisha Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Ombi la uoanishaji"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Gusa ili uoanishe na <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"Bluetooth imezimwa"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Gusa ili uiwashe"</string>
    <string name="device_picker" msgid="2427027896389445414">"Chagua kifaa cha Bluetooth"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"<xliff:g id="APP_NAME">%1$s</xliff:g> inataka kuwasha Bluetooth"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"<xliff:g id="APP_NAME">%1$s</xliff:g> inataka kuzima Bluetooth"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"Programu inataka kuwasha Bluetooth"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"Programu fulani inataka kuzima Bluetooth"</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Inawasha Bluetooth..."</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Inazima Bluetooth..."</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Muunganisho wa Bluetooth umeombwa"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Ombi la kufikia anwani kwenye simu"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Ombi la kufikia ujumbe"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Inaonekana kama \'<xliff:g id="DEVICE_NAME">^1</xliff:g>\' kwenye vifaa vingine"</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Washa Bluetooth ili uunganishe kwenye vifaa vingine."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Vifaa vyako"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Unganisha kifaa kipya"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Zima upakiaji wa maunzi kwa Bluetooth A2DP"</string>
    <string name="bluetooth_disable_le_audio_hw_offload" msgid="4656853795514691257">"Zima upakiaji wa maunzi kwa kipengele cha Bluetooth LE audio"</string>
    <string name="bluetooth_disable_hw_offload_dialog_title" msgid="6001142380445276918">"Ungependa Kuzima kisha Uwashe Kifaa?"</string>
    <string name="bluetooth_disable_hw_offload_dialog_message" msgid="1524373895333698779">"Unahitaji uwashe upya kifaa chako ili ubadilishe mipangilio hii."</string>
    <string name="bluetooth_disable_hw_offload_dialog_confirm" msgid="5594859658551707592">"Zima kisha uwashe"</string>
    <string name="bluetooth_disable_hw_offload_dialog_cancel" msgid="3663690305043973720">"Ghairi"</string>
    <string name="bluetooth_disable_leaudio" msgid="8619410595945155354">"Zima Bluetooth LE audio"</string>
    <string name="bluetooth_disable_leaudio_summary" msgid="4756307633476985470">"Huzima kipengele cha Bluetooth LE audio ikiwa kifaa kinatumia maunzi yenye uwezo wa kutumia LE audio."</string>
    <string name="bluetooth_leaudio_mode" msgid="5206961943393400814">"Hali ya Bluetooth LE Audio"</string>
    <string name="bluetooth_show_leaudio_device_details" msgid="3306637862550475370">"Onyesha LE Audio kwenye Maelezo ya Kifaa"</string>
    <string name="bluetooth_bypass_leaudio_allowlist" msgid="7392319491894565552">"Kwepa Faili Zilizoruhusiwa za Bluetooth LE Audio"</string>
    <string name="bluetooth_bypass_leaudio_allowlist_summary" msgid="8999245286359656738">"Tumia LE Audio kwa chaguomsingi hata ikiwa kifaa cha LE Audio hakijathibitishwa kuwa kimetimiza masharti."</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Vifaa vya kuhifadhia data"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Vifaa vya kupiga simu"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Vifaa vingine"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Vifaa vilivyohifadhiwa"</string>
    <string name="connected_device_fast_pair_device_title" msgid="543124539265592392">"Zinazohusishwa na akaunti"</string>
    <string name="connected_device_previously_associated_fast_pair_device_title" msgid="8353405823992023457">"Kilichotumiwa awali kwenye akaunti"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Bluetooth itawaka ili ioanishe"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Mapendeleo ya muunganisho"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Vilivyounganishwa awali"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"Imewasha Bluetooth"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Angalia vyote"</string>
    <string name="connected_device_fast_pair_device_see_all" msgid="4898279230458128620">"Angalia vyote"</string>
    <string name="stylus_device_details_title" msgid="7618295136015480864">"Stylus"</string>
    <string name="stylus_default_notes_app" msgid="4165657465911764628">"Kubonyeza kitufe cha nyuma"</string>
    <string name="stylus_default_notes_summary_work" msgid="4554643411627934223">"<xliff:g id="APP_NAME">%s</xliff:g> (Wasifu wa kazini)"</string>
    <string name="stylus_textfield_handwriting" msgid="2363579035338976327">"Andika kwenye sehemu za maandishi"</string>
    <string name="stylus_ignore_button" msgid="7734540973145241391">"Puuza mibofyo yote ya kitufe cha stylus"</string>
    <string name="stylus_connected_devices_title" msgid="2823967577941359812">"Stylus"</string>
    <string name="audio_streams_empty" msgid="8803517701437394982">"Mitiririko ya maudhui ya sauti haipo karibu."</string>
    <string name="date_and_time" msgid="1788358029823431692">"Tarehe na saa"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Seva mbadala"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Futa"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Mlango wa seva mbadala"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Seva mbadala ya kando ya"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Rejesha kwa chaguo misingi"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Nimemaliza"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Jina la mpangishaji wa seva mbadala"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Zingatia"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"Sawa"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"Jina la mpangaji uliloandika si sahihi."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"Orodha ya kuepusha uliyoichapisha haijaumbizwa vizuri. Andika orodha iliyotenganishwa-kituo cha vikoa vilivyoepuliwa."</string>
    <string name="proxy_error_empty_port" msgid="4250295137005082992">"Unahitaji kujaza uga wa kituo."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"Sehemu ya mlango sharti iwe wazi iwapo sehemu ya mpangishaji haina chochote"</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"Lango uliloandika si halali."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"Seva mbadala ya HTTP inayotumiwa na kivinjari lakini haiwezi kutumika na programu zingine."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"URL ya PAC: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Ita Jina la mpangishaji(www.google.com) IPv4:"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"Jaribio la Mteja la HTTP:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Tekeleza Jaribio la Mwito"</string>
    <string name="skip_label" msgid="6380034601349015895">"Ruka"</string>
    <string name="next_label" msgid="1248293387735652187">"Endelea"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Lugha"</string>
    <string name="language_picker_category_title" msgid="1792199453060454565">"Mpangilio wa lugha unayopendelea"</string>
    <string name="desc_current_default_language" msgid="1901157141663662859">"Lugha ya mfumo"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Ondoa"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Ongeza lugha nyingine"</string>
    <string name="app_locale_preference_title" msgid="5513627099300360232">"Lugha"</string>
    <string name="locale_picker_category_title" msgid="6212064706962721255">"Lugha Inayopendelewa"</string>
    <string name="app_locales_picker_menu_title" msgid="7617427959223831373">"Lugha za programu"</string>
    <string name="app_locale_picker_summary" msgid="6742557329924446252">"Weka lugha ya kila programu"</string>
    <string name="app_locale_picker_title" msgid="2431448962911301366">"Lugha ya programu"</string>
    <string name="suggested_app_locales_title" msgid="8898358282377369405">"Lugha zinazopendekezwa"</string>
    <string name="all_supported_app_locales_title" msgid="5479289964316009026">"Lugha zote"</string>
    <string name="preference_of_system_locale_title" msgid="8067226276038751504">"Lugha ya mfumo"</string>
    <string name="preference_of_system_locale_summary" msgid="5612241394431188535">"Chaguomsingi la mfumo"</string>
    <string name="desc_no_available_supported_locale" msgid="7883271726226947273">"Chaguo la lugha kwa programu hii halipatikani kwenye Mipangilio."</string>
    <string name="desc_app_locale_disclaimer" msgid="5295933110644789052">"Huenda lugha ikatofautiana na zinazopatikana katika programu. Huenda baadhi ya programu zisiwe na uwezo wa kutumia mipangilio hii."</string>
    <string name="desc_app_locale_selection_supported" msgid="6744909281573556379">"Weka lugha ya kila programu."</string>
    <string name="desc_introduction_of_language_picker" msgid="1038423471887102449">"Mfumo wako, programu na tovuti hutumia lugha ya kwanza inayotumika katika chaguo za lugha unazozipendelea."</string>
    <string name="desc_notice_of_language_picker" msgid="3449290526457925447">"Ili uchague lugha kwa kila programu, nenda kwenye mipangilio ya lugha ya programu."</string>
    <string name="desc_locale_helper_footer_general" msgid="6112153921151780303">"Pata maelezo zaidi kuhusu lugha za programu"</string>
    <string name="title_change_system_locale" msgid="8589844586256566951">"Ungependa kubadilisha lugha ya mfumo kuwa %s ?"</string>
    <string name="title_system_locale_addition" msgid="8218683660751479466">"Ungependa kuweka %s kwenye lugha unazopendelea?"</string>
    <string name="desc_system_locale_addition" msgid="3409917362651596070">"Hii huruhusu programu na vifaa kujua kuwa pia unapendelea lugha hii."</string>
    <string name="desc_notice_device_locale_settings_change" msgid="8311132485850714160">"Mipangilio ya kifaa chako na mapendeleo ya kimaeneo yatabadilika."</string>
    <string name="button_label_confirmation_of_system_locale_change" msgid="5593798559604894733">"Badilisha"</string>
    <string name="title_unavailable_locale" msgid="2628898110416542386">"%s haipatikani"</string>
    <string name="desc_unavailable_locale" msgid="2201756477400935896">"Lugha hii haiwezi kutumika kama lugha ya mfumo, lakini umeruhusu programu na tovuti zitambue kuwa unapendelea lugha hii."</string>
    <string name="regional_preferences_title" msgid="4304567374498629528">"Mapendeleo ya kimaeneo"</string>
    <string name="regional_preferences_summary" msgid="1189876997389469650">"Weka mapendeleo ya vipimo na namba"</string>
    <string name="regional_preferences_main_page_sub_title" msgid="4237109940015254725">"Ruhusu programu zifahamu mapendeleo yako ya kimaeneo ili ziweze kuwekea hali yako ya utumiaji mapendeleo."</string>
    <string name="regional_preferences_option_page_sub_title" msgid="8303661099255197036">"Programu zitatumia mapendeleo yako ya kimaeneo inapowezekana."</string>
    <string name="temperature_preferences_title" msgid="5009881556503629058">"Halijoto"</string>
    <string name="first_day_of_week_preferences_title" msgid="1971850087589599553">"Siku ya kwanza ya wiki"</string>
    <string name="numbers_preferences_title" msgid="8197418984391195446">"Mapendeleo ya namba"</string>
    <string name="default_string_of_regional_preference" msgid="3428899072914884203">"Tumia mipangilio chaguomsingi"</string>
    <string name="celsius_temperature_unit" msgid="8896459071273084507">"Selsiasi (°C)"</string>
    <string name="fahrenheit_temperature_unit" msgid="1118677820614569801">"Farenhaiti (°F)"</string>
    <string name="sunday_first_day_of_week" msgid="7644548348295686051">"Jumapili"</string>
    <string name="monday_first_day_of_week" msgid="7244698610476506771">"Jumatatu"</string>
    <string name="tuesday_first_day_of_week" msgid="5085370946936582391">"Jumanne"</string>
    <string name="wednesday_first_day_of_week" msgid="6544537589727042869">"Jumatano"</string>
    <string name="thursday_first_day_of_week" msgid="3035885630945594833">"Alhamisi"</string>
    <string name="friday_first_day_of_week" msgid="7074795061812083541">"Ijumaa"</string>
    <string name="saturday_first_day_of_week" msgid="3702282590450322727">"Jumamosi"</string>
    <string name="title_regional_pref_footer" msgid="7450438024324794380">"Ikiwa programu hairuhusu mapendeleo ya kimaeneo, programu itatumia mipangilio yake chaguomsingi ya lugha."</string>
    <string name="desc_regional_pref_footer_learn_more" msgid="4401708653329230081">"Pata maelezo zaidi kuhusu mapendeleo ya lugha."</string>
    <string name="category_title_terms_of_address" msgid="4309422700380895278">"Mapendeleo ya ziada"</string>
    <string name="terms_of_address_title" msgid="4064593634733842458">"Maneno ya kukutambulisha"</string>
    <string name="terms_of_address_summary" msgid="6136134336560679144">"Bainisha jinsi ungependa kutambulishwa"</string>
    <string name="terms_of_address_intro_title" msgid="6149691509414243483">"Programu zinaweza kutumia maneno ya kukutambulisha kuwekea mapendeleo jinsi ya kuwasiliana nawe."</string>
    <string name="terms_of_address_not_specified" msgid="4439257779351251973">"Hayajabainishwa"</string>
    <string name="terms_of_address_feminine" msgid="1743479869695539283">"Jinsia ya kike"</string>
    <string name="terms_of_address_masculine" msgid="983106046135098856">"Jinsia ya kiume"</string>
    <string name="terms_of_address_neutral" msgid="5475414185543112478">"Wastani"</string>
    <string name="dlg_remove_locales_title" msgid="3170501604483612114">"{count,plural, =1{Ungependa kuondoa lugha iliyochaguliwa?}other{Ungependa kuondoa lugha zilizochaguliwa?}}"</string>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Maandishi yataonyeshwa katika lugha nyingine."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Haiwezi kuondoa lugha zote"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Hifadhi angalau lugha moja unayopendelea"</string>
    <string name="locale_not_translated" msgid="3071618135527110152">"Haipatikani kama lugha ya mfumo"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Sogeza juu"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Sogeza chini"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Hamishia juu"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Hamishia chini"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Ondoa lugha"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Chagua shughuli"</string>
    <string name="cancel" msgid="5780102414089664898">"Ghairi"</string>
    <string name="okay" msgid="4827099303045669054">"Sawa"</string>
    <string name="forget" msgid="3754013654135912783">"Sahau"</string>
    <string name="save" msgid="3125033126936493822">"Hifadhi"</string>
    <string name="done" msgid="7497982645646431310">"Nimemaliza"</string>
    <string name="apply" msgid="7834684883190163536">"Tumia"</string>
    <string name="share" msgid="8502235338607613795">"Shiriki"</string>
    <string name="add" msgid="8335206931421683426">"Ongeza"</string>
    <string name="remove" msgid="1028414219245072102">"Ondoa"</string>
    <string name="settings_label" msgid="943294133671632976">"Mipangilio"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Mipangilio"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Mipangilio ya njia ya mkato"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Hali ya ndegeni"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Mitandao isiyotumia waya"</string>
    <string name="roaming" msgid="3055365654530847985">"Kutumia mitandao ya ng\'ambo"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Unganisha huduma ya data  wakati natumia mtandao wa ng\'ambo"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Unganisha huduma ya data wakati natumia mtandao wa ng\'ambo"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Huenda ukatozwa ada za kutumia mitandao ya ng\'ambo."</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Weka saa kiotomatiki"</string>
    <string name="zone_auto_title" msgid="5141692422373097957">"Weka saa za eneo kiotomatiki"</string>
    <string name="auto_zone_requires_location_summary" msgid="4831038184260596735">"Data ya mahali itatumika kuweka saa za eneo unapowasha kitufe hiki"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Tumia chaguomsingi la eneo"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"Tumia mpangilio wa saa 24"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Saa"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Mfumo wa saa"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Saa za eneo"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Chagua saa za eneo"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Tarehe"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Tafuta eneo"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Ukanda"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"Chagua mabadiliko kwenye UTC"</string>
    <string name="zone_info_exemplar_location_and_offset" msgid="2186042522225153092">"<xliff:g id="EXEMPLAR_LOCATION">%1$s</xliff:g> (<xliff:g id="OFFSET">%2$s</xliff:g>)"</string>
    <string name="zone_info_offset_and_name" msgid="3960192548990990152">"<xliff:g id="TIME_TYPE">%2$s</xliff:g> (<xliff:g id="OFFSET">%1$s</xliff:g>)"</string>
    <string name="zone_info_footer_first_sentence" msgid="1326664252091302458">"Inatumia <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> itaanza <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8399585343328811158">"Hutumia <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Hakuna mabadiliko kwenye saa za mchana."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Kuongeza saa za mchana"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Saa za kawaida"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Chagua kulingana na eneo"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Chagua kulingana na saa za UTC"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Ijifunge muda wa skrini kujizima ukifika"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> baada ya muda wa skrini kuisha"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Mara tu muda wa skrini unapokwisha, isipokuwa kinapowekwa bila kufungwa na <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> baada ya muda wa skrini kuisha, isipokuwa kinapowekwa bila kufungwa na <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g>"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Weka maandishi kwenye skrini iliyofungwa"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Hamna"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"Mfano, Android ya Joe."</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Kutambua Mahali"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Tumia kipengele cha mahali"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Umezima"</string>
    <string name="location_settings_summary_location_on" msgid="4273299717586679786">"{count,plural, =1{Imewashwa / programu # ina idhini ya kufikia data ya mahali}other{Imewashwa / programu # zina idhini ya kufikia data ya mahali}}"</string>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Inapakia…"</string>
    <string name="location_settings_footer_general" msgid="1040507068701188821">"Programu zenye ruhusa ya Uhamishaji wa Karibu zinaweza kubainisha mahali vilipo vifaa vilivyounganishwa."</string>
    <string name="location_settings_footer_location_off" msgid="8568995909147566720">"Ruhusa za kufikia mahali zimezimwa kwenye programu na huduma. Bado maelezo ya mahali kilipo kifaa chako yanaweza kutumwa kwa wanaoshughulikia matukio ya dharura unapopiga simu au kutuma SMS kwa namba ya dharura."</string>
    <string name="location_settings_footer_learn_more_content_description" msgid="349380666660145540">"Pata maelezo zaidi kuhusu Mipangilio ya mahali"</string>
    <string name="location_settings_tooltip_text_for_chrome" msgid="3574930966097093550">"Ili ubadilishe idhini ya mahali, fungua Mipangilio &gt; Usalama na Faragha &gt; Vidhibiti vya faragha"</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Akaunti"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Usalama"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Vitambulisho na usimbaji fiche"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Skrini iliyofungwa"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Cha kuonyesha"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Haipatikani"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Hali ya usalama"</string>
    <string name="security_dashboard_summary" msgid="7571035662779425918">"Kufunga skrini, Tafuta Kifaa Changu, usalama wa programu"</string>
    <string name="safety_center_title" msgid="7732397372178774777">"Usalama na faragha"</string>
    <string name="safety_center_summary" msgid="3554867379951053869">"Usalama wa programu, ufungaji wa kifaa, ruhusa"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Utambuzi wa uso umewekwa"</string>
    <string name="security_settings_face_preference_summary_none" msgid="523320857738436024">"Unahitaji kuweka mipangilio"</string>
    <string name="security_settings_face_preference_title" msgid="2126625155005348417">"Kufungua kwa uso"</string>
    <string name="security_settings_face_profile_preference_title" msgid="7519527436266375005">"Kufungua kwa uso kwenye wasifu wa kazini"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6448806884597691208">"Jinsi ya kuweka mipangilio ya Kufungua kwa uso"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="3701874093226957891">"Weka mipangilio ya Kufungua kwa uso"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Tumia uso wako kuthibitisha"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Anza"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="2965952386172202665">"Ikiwa kipengele cha ufikivu cha Kufungua kwa uso kimezimwa, huenda baadhi ya hatua za kuweka mipangilio zisifanye kazi vizuri pamoja na TalkBack."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Rudi nyuma"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Endelea kuweka mipangilio"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Tumia mipangilio ya ufikivu"</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">"Ghairi"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Hapana"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"Ninakubali"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Zaidi"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Fungua ukitumia uso wako"</string>
    <string name="security_settings_face_enroll_consent_introduction_title" msgid="3942331854413767814">"Ruhusu kipengele cha kufungua kwa uso"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Tumia uso wako kuthibitisha"</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Tumia uso wako kufungua simu yako au kuidhinisha ununuzi.\n\nKumbuka: Huwezi kutumia uso wako kufungua kifaa hiki. Kwa maelezo zaidi, wasiliana na msimamizi wa shirika lako."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Tumia uso wako kufungua simu yako, kuidhinisha ununuzi au kuingia katika akaunti za programu."</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">"Weka uso wako katikati ya mduara"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Ruka"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Umeongeza idadi ya juu inayoruhusiwa ya nyuso"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"Imeshindwa kuongeza nyuso zaidi"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"Usajili wako haujakamilika"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="1674650455786434426">"Sawa"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="7768349698547951750">"Muda wa kusajili uso umefikia kikomo. Jaribu tena."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"Imeshindwa kusajili uso."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Tayari kabisa. Safi."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Nimemaliza"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="6835778900387289683">"Boresha utendaji wa kipengele cha Kufungua kwa uso"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="7055780282999744813">"Weka tena mipangilio ya Kufungua kwa uso"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="4421818770682557621">"Weka tena mipangilio ya Kufungua kwa uso"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Boresha usalama na utendaji"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="6194184776580066012">"Weka mipangilio ya Kufungua kwa uso"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="2670118180411127323">"Futa muundo wako wa sasa wa uso ili uweke tena mipangilio ya Kufungua kwa uso.\n\nMuundo wa uso wako utafutwa kabisa kwa njia salama.\n\nBaada ya kufuta, utahitaji PIN, mchoro au nenosiri lako ili ufungue simu yako au uthibitishe katika programu."</string>
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint" msgid="2469599074650327489">"Futa muundo wako wa sasa wa uso ili uweke tena mipangilio ya Kufungua kwa uso.\n\nMuundo wa uso wako utafutwa kabisa kwa njia salama.\n\nBaada ya kufuta, utahitaji alama ya kidole chako, mchoro au nenosiri lako ili ufungue simu yako au uthibitishe katika programu."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="1638314154119800188">"Tumia kipengele cha Kufungua kwa uso"</string>
    <string name="security_settings_face_settings_preferences_category" msgid="7628929873407280453">"Unapotumia kipengele cha Kufungua kwa uso"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Unafaa kuwa umefungua macho"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Ili ufungue simu, lazima uwe umefungua macho yako"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Omba uthibitishaji kila wakati"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="3498729789625461914">"Iombe uthibitishaji kila wakati unapofungua kwa uso katika programu"</string>
    <string name="security_settings_face_settings_remove_face_model" msgid="812920481303980846">"Futa muundo wa uso"</string>
    <string name="security_settings_face_settings_enroll" msgid="3726313826693825029">"Weka mipangilio ya Kufungua kwa uso"</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2899669764446232715">"Ungependa kufuta muundo wa uso?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="916131485988121592">"Muundo wa uso wako utafutwa kabisa kwa njia salama.\n\nBaada ya kufuta, utahitaji PIN, mchoro au nenosiri lako ili ufungue simu yako au uthibitishe katika programu."</string>
    <string name="security_settings_face_settings_remove_dialog_details_convenience" msgid="475568135197468990">"Muundo wa uso wako utafutwa kabisa kwa njia salama.\n\nBaada ya kufuta, utahitaji PIN, mchoro au nenosiri lako ili ufungue simu yako."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint" msgid="7609582230650860974">"Muundo wa uso wako utafutwa kabisa na kwa usalama.\n\nBaada ya kufutwa, utahitaji kutumia alama ya kidole, PIN, mchoro au nenosiri lako kufungua simu yako au kutekeleza uthibitishaji katika programu."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint_conv" msgid="2627374706274503259">"Muundo wa uso wako utafutwa kabisa na kwa usalama.\n\nBaada ya kufutwa, utahitaji kutumia alama ya kidole, PIN, mchoro au nenosiri lako kufungua simu yako."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="8284262560781442403">"Tumia kipengele cha Kufungua kwa uso ili ufungue simu yako"</string>
    <string name="security_settings_fingerprint" msgid="6387775386189204201">"Alama ya kidole"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Alama ya kidole"</string>
    <string name="security_settings_fingerprint_settings_preferences_category" msgid="8975029409126780752">"Unapotumia kipengele cha Kufungua kwa alama ya kidole"</string>
    <string name="security_settings_work_fingerprint_preference_title" msgid="2076006873519745979">"Alama ya kidole kwenye wasifu wa kazini"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Ongeza alama nyingine ya kidole"</string>
    <string name="security_settings_fingerprint_preference_summary" msgid="8486134175759676037">"{count,plural, =1{Alama ya kidole imewekwa}other{Alama # za vidole zimewekwa}}"</string>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1146977379031250790">"Unahitaji kuweka mipangilio"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="7931650601996313070">"Weka alama ya kidole chako"</string>
    <string name="security_settings_fingerprint_enroll_consent_introduction_title" msgid="2278592030102282364">"Ruhusu kipengele cha kufungua kwa alama ya kidole"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Tumia alama ya kidole chako"</string>
    <string name="security_settings_fingerprint_settings_footer_learn_more" msgid="2508322993726483601">"Pata maelezo zaidi kuhusu kipengele cha Kufungua kwa Alama ya Kidole"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_1" msgid="6808124116419325722">"Uamuzi ni wako"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1" msgid="1122676690472680734">"Uamuzi ni wako na mtoto wako"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2" msgid="5663733424583416266">"Kumbuka"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Tumia alama ya kidole chako kufungua simu yako au kuidhinisha ununuzi.\n\nKumbuka: Huwezi kutumia alama ya kidole chako kufungua kifaa hiki. Kwa maelezo zaidi, wasiliana na msimamizi wa shirika lako."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Ghairi"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"Hapana"</string>
    <string name="security_settings_fingerprint_enroll_introduction_agree" msgid="4068276083536421828">"Ninakubali"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Ungependa kuruka alama ya kidole?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"Itachukua dakika moja au mbili kuweka mipangilio ya alama ya kidole. Kama utaruka hatua hii, unaweza kuongeza alama ya kidole baadaye katika mipangilio."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_setup" msgid="6255210343107484206">"Ukiona aikoni hii, tumia alama ya kidole chako kwa uthibitishaji, kama vile unapoingia katika akaunti ya programu au unapoidhinisha ununuzi"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_1" msgid="4360262371633254407">"Kumbuka"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2" msgid="2580899232734177771">"Jinsi inavyofanya kazi"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2" msgid="5909924864816776516">"Kipengele cha Kufungua kwa Alama ya Kidole huunda muundo wa kipekee wa alama ya kidole chako ili kuthibitisha kuwa ni wewe. Ili uunde muundo wa alama ya kidole wakati wa kuweka mipangilio, utanasa picha za alama ya kidole chako kutoka pembe tofauti."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2" msgid="3493356605815124807">"Kipengele cha Kufungua kwa Alama ya Kidole huunda muundo wa kipekee wa alama ya kidole cha mtoto wako ili kuthibitisha kuwa ni yeye. Ili kuunda muundo huu wa alama ya kidole wakati wa kuweka mipangilio, atapiga picha za alama ya kidole chake kutoka pembe tofauti."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6" msgid="5314031490467481499">"Kwa matokeo bora, tumia ulinzi wa skrini ambao umethibitishwa na Made for Google. Ukitumia ulinzi mwingine wa skrini, alama yako ya kidole huenda isifanye kazi."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6" msgid="3563942520716110478">"Kwa matokeo bora, tumia ulinzi wa skrini ambao umethibitishwa na Made for Google. Ukitumia ulinzi mwingine wa skrini, alama ya kidole ya mtoto wako huenda isifanye kazi."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_learn_more" msgid="5856010507790137793"></string>
    <string name="security_settings_activeunlock_preference_title" msgid="4257580421087062228">"Kufungua kupitia Saa"</string>
    <string name="biometric_settings_intro_with_activeunlock" msgid="5032953826653108646">"Ukiweka mipangilio ya Kufungua kwa Uso na Kufungua kwa Alama ya Kidole, utahitaji kuweka alama ya kidole kwenye simu yako wakati umevaa barakoa au ukiwa penye giza.\n\nKipengele cha Kufungua kupitia Saa ni njia nyingine rahisi ya kufungua simu yako, kwa mfano, wakati vidole vyako vina unyevu au uso wako hautambuliwi."</string>
    <string name="biometric_settings_intro_with_fingerprint" msgid="5881355884547769337">"Kipengele cha Kufungua kupitia Saa ni njia nyingine rahisi ya kufungua simu yako, kwa mfano, wakati alama ya kidole haitambuliwi."</string>
    <string name="biometric_settings_intro_with_face" msgid="7671919122230588521">"Kipengele cha Kufungua kupitia Saa ni njia nyingine rahisi ya kufungua simu yako, kwa mfano, wakati uso wako hautambuliwi."</string>
    <string name="biometric_settings_use_fingerprint_or_watch_for" msgid="1160830065613858095">"Tumia alama ya kidole au saa"</string>
    <string name="biometric_settings_use_face_or_watch_for" msgid="1507077107150278532">"Tumia uso au saa"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_for" msgid="7495835723072020641">"Tumia uso, alama ya kidole au saa"</string>
    <string name="biometric_settings_use_watch_for" msgid="5454545622244040110">"Tumia saa"</string>
    <string name="biometric_settings_use_face_or_watch_preference_summary" msgid="4969685200340861744">"Kwa kutumia uso au saa"</string>
    <string name="biometric_settings_use_fingerprint_or_watch_preference_summary" msgid="2425628094194828407">"Kwa kutumia alama ya kidole au saa"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary" msgid="188805113048792007">"Kwa kutumia uso, alama ya kidole au saa"</string>
    <string name="biometric_settings_use_watch_preference_summary" msgid="2311453276747908475">"Kwa kutumia saa"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_title" msgid="8776904312629209685">"Weka kwanza mbinu ya Kufungua kwa Uso au Alama ya Kidole"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_message" msgid="1669326067732567911">"Unaweza kufungua kwa kutumia saa yako uso wako au alama ya kidole isipotambuliwa"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_title" msgid="6703703635881050623">"Weka kwanza mbinu ya Kufungua kwa Alama ya Kidole"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_message" msgid="4966813766409918392">"Unaweza kufungua kwa kutumia saa yako, alama ya kidole chako isipotambuliwa"</string>
    <string name="security_settings_activeunlock_require_face_setup_title" msgid="1428795376597739880">"Weka kwanza mbinu ya Kufungua kwa Uso"</string>
    <string name="security_settings_activeunlock_require_face_setup_message" msgid="8904070645721933399">"Unaweza kufungua kwa kutumia saa yako wakati uso wako usipotambuliwa"</string>
    <string name="security_settings_activeunlock_biometric_setup" msgid="8876454457817955475">"Weka mipangilio"</string>
    <string name="security_settings_fingerprint_single_watch_preference_summary" msgid="6464470096384164369">"Umeweka alama ya kidole na <xliff:g id="WATCH">%s</xliff:g>"</string>
    <string name="security_settings_fingerprint_multiple_watch_preference_summary" msgid="2259261786932097004">"Umeweka alama za vidole na <xliff:g id="WATCH">%s</xliff:g>"</string>
    <string name="security_settings_face_watch_preference_summary" msgid="5817376447253802793">"Umeweka uso na <xliff:g id="WATCH">%s</xliff:g>"</string>
    <string name="security_settings_fingerprint_single_face_watch_preference_summary" msgid="764951912234638192">"Umeweka uso, alama ya kidole na <xliff:g id="WATCH">%s</xliff:g>"</string>
    <string name="security_settings_fingerprint_multiple_face_watch_preference_summary" msgid="3935500711366489380">"Umeweka uso, alama za vidole na <xliff:g id="WATCH">%s</xliff:g>"</string>
    <string name="security_settings_remoteauth_preference_title" msgid="8319680328086089533">"Kufungua Remote Authenticator"</string>
    <string name="security_settings_remoteauth_preference_summary" msgid="1507004469316635196">"Saa imeoanishwa"</string>
    <string name="security_settings_remoteauth_enroll_introduction_title" msgid="2151004795778999671">"Weka mipangilio ya saa yako"</string>
    <string name="security_settings_remoteauth_enroll_introduction_message" msgid="8737276885766036074">"Kipengele cha Kufungua kupitia Saa ni njia nyingine rahisi ya kufungua simu hii, kwa mfano, wakati vidole vyako vina unyevu au uso wako hautambuliwi.\n\nUnaweza kutumia saa yako kufungua simu wakati:"</string>
    <string name="security_settings_remoteauth_enroll_introduction_disagree" msgid="7639258097401796028">"Si sasa"</string>
    <string name="security_settings_remoteauth_enroll_introduction_agree" msgid="5271119227172049339">"Endelea"</string>
    <string name="security_settings_remoteauth_enroll_introduction_more" msgid="1644105894631257595">"Zaidi"</string>
    <string name="security_settings_remoteauth_enroll_introduction_how_title" msgid="6604152528267830349">"Jinsi inavyofanya kazi"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_lock_open" msgid="8570511335628725116">"Lazima uwe umefungua saa yako, umeivaa na iwe karibu na simu hii. Hutahitaji kufungua tena saa yako ukiwa umeivaa."</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_notifications" msgid="4298855831154039694">"Ukifungua simu hii, utaarifiwa kwenye saa yako. Ikiwa umeifungua bila kukusudia, gusa arifa ili ufunge simu tena."</string>
    <string name="security_settings_remoteauth_enroll_introduction_youre_in_control_title" msgid="7974976673323638524">"Uamuzi ni wako"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_remove_watch" msgid="1888318677088986801">"Unaweza kuondoa saa yako kwenye kipengele cha Kufungua kupitia Saa wakati wowote katika Mipangilio"</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_tap_notification" msgid="1597397399097952974">"Gusa arifa"</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_swipe_up" msgid="2129230804324634653">"Telezesha kidole juu kwenye skrini iliyofungwa"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_title" msgid="313016997943607675">"Chagua saa yako"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_list_heading" msgid="8227585438932911013">"Saa zinazopatikana"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_disagree" msgid="1670201454188049863">"Ghairi"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_agree" msgid="7048336252635730908">"Thibitisha"</string>
    <string name="security_settings_remoteauth_enroll_finish_title" msgid="3807372930755413112">"Kila kitu ni shwari!"</string>
    <string name="security_settings_remoteauth_enroll_finish_description" msgid="4876209907275244653">"Sasa unaweza kutumia saa yako kufungua simu hii unapotelezesha kidole juu kwenye skrini iliyofungwa au unapogusa arifa"</string>
    <string name="security_settings_remoteauth_enroll_finish_btn_next" msgid="8072138423143889592">"Nimemaliza"</string>
    <string name="security_settings_remoteauth_settings_title" msgid="1564912618737165129">"Kufungua kupitia Saa"</string>
    <string name="security_settings_remoteauth_settings_description" msgid="2758239650119457964">"Unaweza kutumia simu yako kufungua simu hii unapotelezesha kidole kwenda juu kwenye skrini iliyofungwa au kugusa arifa"</string>
    <string name="security_settings_remoteauth_settings_info_footer" msgid="795894033901478120">"Ili utumie kipengele cha Kufungua kupitia Saa, ni sharti saa yako iwe imefunguliwa, uwe umeivaa, iweze kuifikia na iunganishwe kwenye simu hii. Muunganisho ukikatizwa, utahitaji kufungua simu kabla ya kuweza kutumia kipengele cha Kufungua kupitia Saa.\n\nKumbuka:\nUnaweza kuweka mipangilio ya saa moja tu kwa wakati mmoja. Ili uweke mipangilio ya saa nyingine, ondoa kwanza mipangilio ya saa iliyopo."</string>
    <string name="security_settings_remoteauth_settings_learn_more" msgid="5653556124819260050">"Pata maelezo zaidi kuhusu Kufungua Kupitia Saa"</string>
    <string name="security_settings_remoteauth_settings_register_new_authenticator" msgid="9191331738306527887">"Weka saa"</string>
    <string name="security_settings_remoteauth_settings_remove_device" msgid="2436226120578851282">"Ondoa saa"</string>
    <string name="security_settings_biometric_preference_title" msgid="5012627247749093938">"Alama ya Kidole na Kufungua kwa Uso"</string>
    <string name="security_settings_work_biometric_preference_title" msgid="3121755615533533585">"Kazini: Kufungua kwa Uso na Alama ya Kidole"</string>
    <string name="security_settings_biometric_preference_summary_none_enrolled" msgid="213377753727694575">"Unahitaji kuweka mipangilio"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_multiple" msgid="4821859306609955966">"Uso na alama za vidole zimeongezwa"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_single" msgid="684409535278676426">"Uso na alama ya kidole imeongezwa"</string>
    <string name="biometric_settings_intro" msgid="4263069383955676756">"Ukiweka mbinu ya Kufungua kwa uso na Kufungua kwa alama ya kidole, simu yako itakuomba alama ya kidole wakati umevaa barakoa au ukiwa katika eneo lenye giza"</string>
    <string name="biometric_settings_category_ways_to_unlock" msgid="3384767901580915266">"Mbinu za kufungua"</string>
    <string name="biometric_settings_category_use_face_fingerprint" msgid="4377659744376863913">"Tumia uso au alama ya kidole ili"</string>
    <string name="biometric_settings_use_biometric_unlock_phone" msgid="8180914579885804358">"Kufungua simu yako"</string>
    <string name="biometric_settings_use_biometric_for_apps" msgid="6201168728906364189">"Kuthibitisha ni wewe katika programu"</string>
    <string name="biometric_settings_use_face_preference_summary" msgid="1821648836899408477">"Kutumia uso"</string>
    <string name="biometric_settings_use_fingerprint_preference_summary" msgid="6077762097826050165">"Ukitumia alama ya kidole"</string>
    <string name="biometric_settings_use_face_or_fingerprint_preference_summary" msgid="3029102492674234728">"Ukitumia uso au alama ya kidole"</string>
    <string name="biometric_settings_hand_back_to_guardian_ok" msgid="1763788801883247426">"Sawa"</string>
    <string name="biometric_settings_add_face_in_split_mode_title" msgid="6041232223862753222">"Imeshindwa kuweka mipangilio ya Kufungua kwa Uso"</string>
    <string name="biometric_settings_add_face_in_split_mode_message" msgid="1904738532939614456">"Ondoka kwenye hali ya kugawa skrini ili uweke mipangilio ya Kufungua kwa Uso"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_title" msgid="9194670722730454903">"Imeshindwa kuweka mipangilio ya alama ya kidole"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_message" msgid="6960548382076629454">"Ondoka kwenye hali ya kugawa skrini ili uweke mipangilio ya Kufungua kwa alama ya kidole"</string>
    <string name="biometric_settings_add_biometrics_in_split_mode_ok" msgid="564103789097253645">"Sawa"</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Ungependa kuruka hatua ya kufunga skrini?"</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Ruka"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Rudi nyuma"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Ruka"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Ghairi"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Gusa kitambua alama ya kidole"</string>
    <string name="security_settings_sfps_enroll_find_sensor_title" msgid="8327884364635804363">"Gusa kitufe cha kuwasha/kuzima bila kukibonyeza"</string>
    <string name="security_settings_udfps_enroll_find_sensor_title" msgid="8077484429913330179">"Jinsi ya kuweka mipangilio ya alama ya kidole chako"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"Kinapatikana nyuma ya simu yako. Tumia kidole chako cha shahada."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="8383106460819519961">"Kitambua alama ya kidole kiko kwenye skrini yako. Utanasa alama ya kidole chako kwenye skrini inayofuata."</string>
    <string name="security_settings_udfps_enroll_find_sensor_start_button" msgid="3172268783620336357">"Anza"</string>
    <string name="security_settings_udfps_enroll_a11y" msgid="1899453114050362235">"Sogeza kidole chako kwenye skrini ili ukipate. Gusa na ushikilie kitambua alama ya kidole."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Mchoro unaooyesha mahali kitambua alama ya kidole kilipo kwenye kifaa"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Jina"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"SAWA"</string>
    <string name="security_settings_fingerprint_enroll_dialog_try_again" msgid="8117874972945407006">"Jaribu tena"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Futa"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Gusa kitambua alama ya kidole"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Weka kidole chako juu ya kitambua alama kisha ukiinue baada ya kuhisi mtetemo"</string>
    <string name="security_settings_udfps_enroll_start_message" msgid="5032954588171487566">"Usiinue kidole chako kwenye kitambuzi hadi utakapohisi mtetemo"</string>
    <string name="security_settings_sfps_enroll_start_message" msgid="9054672627477685212">"Bila kubonyeza kitufe, endelea kuweka alama ya kidole chako kwenye kitambuzi hadi utakapohisi mtetemo.\n\nSogeza kidole chako kiasi kila wakati. Hatua hii inasaidia kunasa asilimia kubwa ya alama ya kidole chako."</string>
    <string name="security_settings_fingerprint_enroll_udfps_title" msgid="6665610134560896895">"Gusa na ushikilie kitambua alama ya kidole"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Inua, kisha uguse tena"</string>
    <string name="security_settings_udfps_enroll_title_one_more_time" msgid="424937043843482410">"Gusa mara nyingine"</string>
    <string name="security_settings_udfps_enroll_repeat_title_touch_icon" msgid="4096344864386190335">"Fuata aikoni ya alama ya kidole"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Endelea kuinua kidole chako ili uongeze sehemu tofauti za alama ya kidole chako"</string>
    <string name="security_settings_udfps_enroll_repeat_message" msgid="2213106975297867798">"Gusa na ushikilie kila mara aikoni ya alama ya kidole inaposogea. Hatua hii husaidia kunasa sehemu nyingi za alama ya kidole chako."</string>
    <string name="security_settings_udfps_enroll_fingertip_title" msgid="4123142574168831116">"Weka ncha ya kidole chako kwenye kitambuzi"</string>
    <string name="security_settings_udfps_enroll_left_edge_title" msgid="1944076382202470458">"Weka ukingo wa kushoto wa kidole chako"</string>
    <string name="security_settings_udfps_enroll_right_edge_title" msgid="9036744264606447490">"Weka ukingo wa kulia wa kidole chako"</string>
    <string name="security_settings_sfps_enroll_finger_center_title" msgid="1320688855767675739">"Weka sehemu ya katikati ya kidole chako kwenye kitambuzi"</string>
    <string name="security_settings_sfps_enroll_fingertip_title" msgid="2737520837684516446">"Weka ncha ya kidole chako kwenye kitambuzi"</string>
    <string name="security_settings_sfps_enroll_left_edge_title" msgid="9022963735924413343">"Weka ukingo wa kushoto wa kidole chako kwenye kitambuzi"</string>
    <string name="security_settings_sfps_enroll_right_edge_title" msgid="823106857743394392">"Hatimaye, weka ukingo wa kulia wa kidole chako kwenye kitambuzi"</string>
    <string name="security_settings_udfps_enroll_edge_message" msgid="4455253923746607702">"Weka upande mmoja wa alama ya kidole chako kwenye kitambuzi na ushikilie, kisha ubadili upande mwingine"</string>
    <string name="security_settings_udfps_enroll_repeat_a11y_message" msgid="2785464357615568197">"Hatua hii husaidia kunasa sehemu nyingi za alama ya kidole chako"</string>
    <string name="security_settings_sfps_enroll_progress_a11y_message" msgid="6450772721691523736">"Inaandikisha asilimia <xliff:g id="PERCENTAGE">%d</xliff:g> ya alama ya kidole"</string>
    <string name="security_settings_sfps_animation_a11y_label" msgid="8808819903730940446">"Imeandikishwa kwa asilimia <xliff:g id="PERCENTAGE">%d</xliff:g>"</string>
    <string name="security_settings_udfps_enroll_progress_a11y_message" msgid="6183535114682369699">"Imeandikisha asilimia <xliff:g id="PERCENTAGE">%d</xliff:g> ya alama ya kidole"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Alama ya kidole imeongezwa"</string>
    <string name="security_settings_require_screen_on_to_auth_title" msgid="1641621458536715518">"Gusa ili ufungue wakati wowote"</string>
    <string name="security_settings_require_screen_on_to_auth_description" msgid="4158414711168345398">"Gusa kitambuzi ili ufungue, hata wakati skrini imezimwa. Hatua hii inaongeza uwezekano wa kufungua bila kukusudia."</string>
    <string name="security_settings_require_screen_on_to_auth_keywords" msgid="5557869560397089603">"Skrini, Fungua"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Weka baadaye"</string>
    <string name="security_settings_udfps_tip_fingerprint_help" msgid="7580784640741217494">"Inua, kisha uguse tena"</string>
    <string name="security_settings_udfps_side_fingerprint_help" msgid="2567232481013195191">"Weka upande mmoja wa kidole chako kwenye kitambuzi na ushikilie, kisha uweke upande wa pili"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"Ungependa kuruka kuweka alama ya kidole?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"Umechagua kutumia alama ya kidole chako kama njia ya kufungua simu yako. Ukiruka sasa, utahitajika kusanidi hii baadaye. Usanidi huchukua takriban dakika moja."</string>
    <string name="lock_screen_skip_setup_title" msgid="6979006375138175111">"Ungependa kuruka kuweka mipangilio ya <xliff:g id="OPTIONS">%s</xliff:g>?"</string>
    <string name="lock_screen_pin_skip_title" msgid="6853866579893458111">"Ungependa kuruka Kuweka PIN?"</string>
    <string name="lock_screen_pin_skip_face_title" msgid="8810770395309512358">"Ungependa kuruka hatua ya kuweka PIN na uso?"</string>
    <string name="lock_screen_pin_skip_fingerprint_title" msgid="371214283158750976">"Ungependa kuruka hatua ya kuweka PIN na alama ya kidole?"</string>
    <string name="lock_screen_pin_skip_biometrics_title" msgid="1082066572914073311">"Utaruka kuweka PIN, uso na alama ya kidole?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Ungependa kuruka Kuweka Nenosiri?"</string>
    <string name="lock_screen_password_skip_face_title" msgid="8166210519462164998">"Utaruka hatua ya kuweka nenosiri na uso?"</string>
    <string name="lock_screen_password_skip_fingerprint_title" msgid="2506392546016772170">"Utaruka kuweka nenosiri na alama ya kidole?"</string>
    <string name="lock_screen_password_skip_biometrics_title" msgid="900281322095862009">"Utaruka kuweka nenosiri, uso na alama ya kidole?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Ungependa kuruka Kuweka Mchoro?"</string>
    <string name="lock_screen_pattern_skip_face_title" msgid="145100333454316334">"Ungependa kuruka hatua ya kuweka mchoro na uso?"</string>
    <string name="lock_screen_pattern_skip_fingerprint_title" msgid="2513110208722100495">"Utaruka kuweka mchoro na alama ya kidole?"</string>
    <string name="lock_screen_pattern_skip_biometrics_title" msgid="2434258106825380187">"Utaruka kuweka mchoro, uso na alama ya kidole?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Weka mbinu ya kufunga skrini"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Nimemaliza"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Lo, hicho si kitambuzi"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Gusa kitambua alama ya kidole kilicho nyuma ya simu yako. Tumia kidole chako cha shahada."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_dialog_title" msgid="6305457126747942642">"Haijakamilisha mipangilio ya alama ya kidole"</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message_setup" msgid="2735739618722623980">"Unaweza kujaribu tena sasa au uweka alama yako ya kidole baadaye katika Mipangilio."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message" msgid="5858386244898601003">"Unaweza kujaribu tena sasa au uweke alama yako ya kidole baadaye."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="8582267776559099046">"Muda wa kuweka alama ya kidole umeisha"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message_setup" msgid="8521566666541069383">"Unaweza kuweka alama yako ya kidole baadaye katika Mipangilio."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message_setup" msgid="8140162986046783546">"Hitilafu fulani imetokea. Unaweza kuweka alama yako ya kidole baadaye katika Mipangilio."</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="3534341971920335247">"Unaweza kuweka alama yako ya kidole baadaye."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="4344665784935791640">"Hitilafu fulani imetokea. Unaweza kuweka alama yako ya kidole baadaye."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Ongeza kingine"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Endelea"</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_1" msgid="294529888220959309">"Chaguo la kufunga skrini limezimwa. Ili upate maelezo zaidi, wasiliana na msimamizi wako wa shirika."</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_2" msgid="8070829069640846543">"Bado unaweza kutumia alama ya kidole chako kuidhinisha ununuzi na uwezo wa kufikia programu."</string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Inua kidole, kisha gusa kitambuzi tena"</string>
    <string name="security_settings_fingerprint_bad_calibration_title" msgid="3073145395701953620">"Imeshindwa kutumia kitambuzi cha alama ya kidole"</string>
    <string name="security_settings_fingerprint_bad_calibration" msgid="304585658839584958">"Tembelea mtoa huduma za urekebishaji."</string>
    <string name="security_advanced_settings" msgid="6260756619837834042">"Mipangilio zaidi ya usalama"</string>
    <string name="security_advanced_settings_work_profile_settings_summary" msgid="7295451997961973175">"Ufungaji wa wasifu wa kazini, usimbaji fiche na zaidi"</string>
    <string name="security_advanced_settings_no_work_profile_settings_summary" msgid="345336447137417638">"Usimbaji fiche, vitambulisho na zaidi"</string>
    <string name="security_advanced_settings_keywords" msgid="5294945170370974974">"usalama, mipangilio zaidi ya usalama, mipangilio zaidi, mipangilio ya kina ya usalama"</string>
    <string name="privacy_advanced_settings" msgid="8828215456566937719">"Mipangilio zaidi ya faragha"</string>
    <string name="more_security_privacy_settings" msgid="123465614090328851">"Usalama na faragha zaidi"</string>
    <string name="security_header" msgid="961514795852103424">"Usalama"</string>
    <string name="privacy_header" msgid="5526002421324257007">"Faragha"</string>
    <string name="work_profile_category_header" msgid="85707750968948517">"Wasifu wa kazini"</string>
    <string name="private_space_title" msgid="1752064212078238723">"Sehemu ya faragha"</string>
    <string name="private_space_summary" msgid="2274405892301976238">"Funga na ufiche programu za faragha"</string>
    <string name="private_space_description" msgid="4059594203775816136">"Weka programu za faragha kwenye nafasi tofauti unayoweza kuficha au kufunga"</string>
    <string name="private_space_lock_title" msgid="7230836881433350526">"Mbinu ya kufunga sehemu ya faragha"</string>
    <string name="private_space_one_lock_summary" msgid="2106513606571219068">"Unaweza kufungua sehemu yako ya faragha kupitia mbinu unayotumia kufungua kifaa chako au uchague mbinu tofauti ya kufunga"</string>
    <string name="private_space_screen_lock_title" msgid="8679383894967823163">"Tumia mbinu ya kufunga skrini ya kifaa"</string>
    <string name="private_space_biometric_title" msgid="3934339826674553174">"Kipengele cha Kufungua kwa Alama ya Kidole na Uso"</string>
    <string name="private_space_fingerprint_title" msgid="5989254643211889931">"Kufungua kwa Alama ya Kidole"</string>
    <string name="private_space_face_title" msgid="3290402865367663079">"Kipengele cha Kufungua kwa Uso"</string>
    <string name="private_space_biometric_summary" msgid="4403837276018724581">"Gusa ili uweke mipangilio"</string>
    <string name="private_space_fingerprint_unlock_title" msgid="3614016453395789051">"Kufungua sehemu ya faragha kwa alama ya kidole"</string>
    <string name="private_space_face_unlock_title" msgid="462248384776453613">"Kufungua sehemu ya faragha kwa kutumia uso"</string>
    <string name="private_space_category_ways_to_unlock" msgid="4356631225316950046">"Mbinu za kufungua"</string>
    <string name="private_space_screen_lock_summary" msgid="394837965365561070">"Mbinu sawa ya kufunga skrini ya kifaa"</string>
    <string name="private_space_new_lock_title" msgid="9056139964133004094">"Ungependa kuchagua mbinu mpya ya kufunga sehemu ya faragha?"</string>
    <string name="private_space_auto_lock_title" msgid="8663409382910601261">"Kufunga sehemu ya faragha kiotomatiki"</string>
    <string name="private_space_auto_lock_page_summary" msgid="8679844515655838654">"Unaweza kufunga sehemu yako ya faragha kiotomatiki ikiwa hujatumia kifaa chako kwa muda"</string>
    <string name="private_space_auto_lock_every_time" msgid="1215061855836002830">"Kila wakati kifaa kinapojifunga"</string>
    <string name="private_space_auto_lock_after_inactivity" msgid="1748673030841528649">"Ikikaa kwa dakika 5 bila shughuli"</string>
    <string name="private_space_auto_lock_never" msgid="595014527119778873">"Kisifunge kamwe"</string>
    <string name="private_space_hide_title" msgid="8687034008994037610">"Ficha wakati umefunga"</string>
    <string name="privatespace_hide_page_title" msgid="8417507414027827566">"Ficha sehemu ya faragha ikiwa imefungwa"</string>
    <string name="privatespace_hide_page_summary" msgid="5525422595477989312">"Ili kuzuia watu wengine wasijue kuwa una sehemu ya faragha kwenye kifaa chako, unaweza kuificha kwenye orodha ya programu"</string>
    <string name="privatespace_access_header" msgid="6066826215718835041">"Kufikia sehemu ya faragha ikiwa imefichwa"</string>
    <string name="privatespace_search_description" msgid="3121043205513022357">"Kwenye orodha yako ya programu, andika \"sehemu ya faragha\" kwenye upau wa kutafutia"</string>
    <string name="privatespace_tap_tile_description" msgid="8346440188590931635">"Gusa kigae cha sehemu ya faragha"</string>
    <string name="privatespace_unlock_description" msgid="3177710543121916413">"Fungua sehemu yako ya faragha"</string>
    <string name="privatespace_hide_off_summary" msgid="7227778747159633671">"Umezima"</string>
    <string name="privatespace_hide_on_summary" msgid="6136704537527640183">"Umewasha"</string>
    <string name="private_space_category_system" msgid="1286843321867285700">"Mfumo"</string>
    <string name="private_space_delete_title" msgid="636873505724100006">"Futa nafasi ya faragha"</string>
    <string name="private_space_delete_header" msgid="4594429153176776184">"Ungependa kufuta sehemu ya faragha?"</string>
    <string name="private_space_delete_summary" msgid="3344372988408565545">"Sehemu yako ya faragha itaondolewa kwenye kifaa hiki. Data na programu zote za faragha zitafutwa. Huwezi kutendua kitendo hiki."</string>
    <string name="private_space_accounts" msgid="1078277762792056395">"Akaunti zifuatazo zitaondelewa kwenye sehemu yako ya faragha:"</string>
    <string name="private_space_delete_button_label" msgid="1256981385318225002">"Futa"</string>
    <string name="private_space_confirm_deletion_header" msgid="3468651585498942977">"Inafuta sehemu ya faragha…"</string>
    <string name="private_space_confirm_deletion_summary" msgid="342544588554284686">"Hatua hii itachukua dakika chache"</string>
    <string name="private_space_deleted" msgid="7692240901492540053">"Imefuta sehemu ya faragha"</string>
    <string name="private_space_delete_failed" msgid="7705795653796174741">"Imeshindwa kufuta sehemu ya faragha"</string>
    <string name="private_space_unlocked" msgid="9091600948712932046">"Nafasi ya faragha imefunguliwa"</string>
    <string name="no_device_lock_title" msgid="1078223464721029954">"Weka mbinu ya kufunga skrini"</string>
    <string name="no_device_lock_summary" msgid="7436025227616244687">"Ili utumie nafasi ya faragha, weka kipengele cha kufunga skrini kwenye kifaa hiki"</string>
    <string name="no_device_lock_action_label" msgid="2640487005629001288">"Weka mbinu ya kufunga skrini"</string>
    <string name="no_device_lock_cancel" msgid="4412602160321228863">"Ghairi"</string>
    <string name="private_space_cancel_label" msgid="379259667396956886">"Acha"</string>
    <string name="private_space_setup_button_label" msgid="2094882154623560585">"Weka mipangilio"</string>
    <string name="private_space_setup_title" msgid="2272968244329821450">"Sehemu ya faragha"</string>
    <string name="private_space_hide_apps_summary" msgid="4418722947376042418">"Ficha au ufunge programu za faragha katika sehemu tofauti. Tumia Akaunti maalum ya Google ili upate usalama zaidi."</string>
    <string name="private_space_setup_sub_header" msgid="5454598292017819146">"Weka mipangilio ya sehemu yako ya faragha"</string>
    <string name="private_space_separate_account_text" msgid="4492251315012955548"><b>"Chagua Akaunti ya Google ya sehemu yako"</b>\n"Kutumia akaunti maalum husaidia kukomesha faili, picha na barua pepe zilizosawazishwa kuonekana nje ya sehemu yako"</string>
    <string name="private_space_protected_lock_text" msgid="9123250938334372735"><b>"Weka mipangilio ya kufunga"</b>\n"Funga sehemu yako ili ukomeshe watu wengine wasiifungue"</string>
    <string name="private_space_install_apps_text" msgid="5693139160766464498"><b>"Weka programu"</b>\n"Sehemu yako ya faragha ina Duka lake binafsi la Google Play kwa hivyo unaweza kuweka programu kwenye vifaa kwa urahisi."</string>
    <string name="private_space_apps_permission_text" msgid="7030946025253366172">"Programu zilizo kwenye sehemu yako ya faragha hazitaonekana kwenye Kidhibiti cha ruhusa, dashibodi ya faragha na mipangilio mingine wakati umefunga sehemu yako ya faragha.\n\nSehemu yako ya faragha haiwezi kuhamishiwa kwenye kifaa kipya. Utahitaji kuweka mipangilio ya sehemu nyingine ya faragha ikiwa ungependa kuitumia kwenye kifaa kingine.\n\nMtu yeyote anayeunganisha kifaa chako kwenye kompyuta au anayeweka programu hatari kwenye kifaa chako huenda akafikia sehemu yako ya faragha."</string>
    <string name="private_space_setting_up_text" msgid="8458035555212009528">"Inaweka mipangilio ya sehemu ya faragha…"</string>
    <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Arifa kutoka programu za sehemu ya faragha hufichwa ukiwa umeifunga"</string>
    <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Gundua mipangilio ya sehemu ya faragha ili ufiche sehemu ya faragha na uweke mipangilio ya kufunga skrini kiotomatiki"</string>
    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
    <skip />
    <string name="private_space_error_screen_title" msgid="739381738044418346">"Imeshindwa kuweka mipangilio ya sehemu ya faragha"</string>
    <string name="private_space_tryagain_label" msgid="8305362615231738367">"Jaribu Tena"</string>
    <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Ungependa kutumia kipengele cha kufunga skrini kufungua sehemu ya faragha?"</string>
    <string name="private_space_lockscreen_summary" msgid="430569465080645805">"Unaweza kufungua sehemu ya faragha kupitia mbinu unayotumia kufungua kifaa chako au uchague mbinu tofauti ya kufunga"</string>
    <string name="private_space_use_screenlock_label" msgid="9182153443192032782">"Tumia mbinu ya kufunga skrini"</string>
    <string name="private_space_set_lock_label" msgid="1790408277477408475">"Chagua mbinu mpya ya kufunga"</string>
    <string name="private_space_success_title" msgid="4351904015352046118">"Tayari!"</string>
    <string name="private_space_access_text" msgid="4433988836344567888">"Ili upate sehemu yako ya faragha, nenda kwenye programu zako zilizoorodheshwa kisha uende chini"</string>
    <string name="private_space_done_label" msgid="1020482651595246071">"Nimemaliza"</string>
    <string name="private_space_scrolldown_to_access" msgid="4820954877349434545">"Nenda chini ili upate sehemu ya faragha"</string>
    <string name="private_space_retry_signin_title" msgid="8090276618867918844">"Ingia katika akaunti"</string>
    <string name="private_space_retry_summary" msgid="1920444015972648774">"Ingia katika akaunti ya kutumia sehemu yako ya faragha"</string>
    <string name="private_space_skip_login_label" msgid="7078019409056628192">"Si sasa"</string>
    <string name="private_space_continue_login_label" msgid="7779965766333065391">"Endelea"</string>
    <string name="private_space_lock_setup_title" msgid="6541564212199510787">"Kuchagua mbinu ya kufunga sehemu yako ya faragha"</string>
    <string name="private_space_lock_setup_description" msgid="423405593476300918">"Unaweza kufungua sehemu yako ya faragha ukitumia alama ya kidole chako. Ili kudumisha usalama, chaguo hili linahitaji mbinu mbadala ya kufunga skrini."</string>
    <string name="private_space_choose_your_pin_header" msgid="4560802934975898265">"Weka PIN ya sehemu yako ya faragha"</string>
    <string name="private_space_choose_your_password_header" msgid="7660259341095044434">"Weka nenosiri la sehemu yako ya faragha"</string>
    <string name="private_space_choose_your_pattern_header" msgid="2165607102459936724">"Weka mchoro wa sehemu yako ya faragha"</string>
    <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Programu na arifa"</string>
    <string name="private_space_notifications_title" msgid="3456249671149740404">"Arifa nyeti kwenye skrini iliyofungwa"</string>
    <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Onyesha maudhui nyeti wakati sehemu ya faragha imefunguliwa"</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">"Unaweza kuongeza hadi alama za vidole <xliff:g id="COUNT">%d</xliff:g>"</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Umeongeza idadi ya juu inayoruhusiwa ya alama za kidole"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Haiwezi kuongeza alama zaidi za kidole"</string>
    <string name="fingerprint_delete_title" msgid="5412123164503407098">"Futa \'<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>\'"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="4104208067277655068">"Hutaweza kutumia alama ya kidole chako kufungua wasifu wako wa kazini, kuidhinisha ununuzi au kuingia katika akaunti za programu za kazini."</string>
    <string name="encryption_settings_title" msgid="2848716008695618360">"Usimbaji fiche"</string>
    <string name="encrypted_summary" msgid="545623487587251207">"Imesimbwa kwa njia fiche"</string>
    <string name="no_screen_lock_issue_title" msgid="1814109590692792891">"Weka mbinu ya kufunga skrini"</string>
    <string name="no_screen_lock_issue_summary" msgid="2383217853510608406">"Ili kuimarisha usalama, weka PIN, mchoro au nenosiri kwenye kifaa hiki."</string>
    <string name="no_screen_lock_issue_action_label" msgid="2691229130486382863">"Weka mbinu ya kufunga skrini"</string>
    <string name="no_screen_lock_issue_notification_title" msgid="1214876733592830628">"Weka mbinu ya kufunga skrini"</string>
    <string name="no_screen_lock_issue_notification_text" msgid="8696194459170873345">"Ili kuimarisha usalama, weka PIN, mchoro au nenosiri kwenye kifaa hiki."</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Linda simu yako"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Weka alama ya kidole ili ufungue"</string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Mbinu ya kufunga skrini"</string>
    <string name="lock_settings_picker_new_lock_title" msgid="3113042086804290919">"Chagua mbinu ya kufunga skrini"</string>
    <string name="lock_settings_picker_update_lock_title" msgid="536853138943415927">"Chagua mbinu mpya ya kufunga skrini"</string>
    <string name="lock_settings_picker_new_profile_lock_title" msgid="2270462215256413800">"Chagua mbinu ya kufunga skrini kwenye programu za kazini"</string>
    <string name="lock_settings_picker_update_profile_lock_title" msgid="5929068163516308927">"Chagua mbinu mpya ya kufunga skrini ya kazini"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Ili uimarishe usalama, weka mbinu mbadala ya kufunga skrini"</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Chagua njia mbadala ya kufunga skrini yako"</string>
    <string name="lock_settings_picker_admin_restricted_personal_message" msgid="3532653662159888328">"Ukisahau mbinu yako ya kufunga skrini, msimamizi wako wa TEHAMA hawezi kuibadilisha."</string>
    <string name="lock_settings_picker_admin_restricted_personal_message_action" msgid="5956615234246626264">"Weka mbinu tofauti ya kufunga ya kazini"</string>
    <string name="lock_settings_picker_profile_message" msgid="9142379549980873478">"Ukisahau mbinu hii ya kufunga skrini, mwombe msimamizi wako wa TEHAMA aibadilishe"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Chaguo za kufunga skrini"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Chaguo za kufunga skrini"</string>
    <string name="lock_screen_auto_pin_confirm_title" msgid="3012128112186088375">"Thibitisha kufungua kiotomatiki"</string>
    <string name="lock_screen_auto_pin_confirm_summary" msgid="9050818870806580819">"Fungua kiotomatiki ukiweka PIN sahihi yenye tarakimu 6 au zaidi. Hatua hii ina usalama kidogo kuliko kugusa \'Weka\' ili kuthibitisha."</string>
    <string name="auto_pin_confirm_user_message" msgid="6194556173488939314">"Thibitisha PIN sahihi kiotomatiki"</string>
    <string name="auto_pin_confirm_opt_in_security_message" msgid="580773976736184893">"Kuthibitisha PIN yako kwa kugusa \'Weka\' ni salama zaidi kuliko kuthibitisha kiotomatiki"</string>
    <string name="auto_confirm_on_pin_verify_description" msgid="2052240431173223502">"Weka PIN ya kifaa ili uwashe mipangilio ya kuthibitisha kiotomatiki"</string>
    <string name="auto_confirm_off_pin_verify_description" msgid="4256219155659760047">"Weka PIN ya kifaa ili uzime mipangilio ya kuthibitisha kiotomatiki"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Kufunga skrini"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Mbinu ya kufunga wasifu wa kazini"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Hamna"</string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Telezesha kidole"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Mchoro"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"PIN"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Nenosiri"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Si sasa"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Mbinu inayotumika kufunga skrini"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="2229689425933043901">"Mchoro • Alama ya kidole"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="7979848492740627674">"PIN • Alama ya kidole"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="6207676267295036963">"Nenosiri • Alama ya kidole"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Endelea bila kutumia alama ya kidole"</string>
    <string name="face_unlock_set_unlock_pattern" msgid="4206669838203096608">"Mchoro • Uso"</string>
    <string name="face_unlock_set_unlock_pin" msgid="9034912683791069602">"PIN • Uso"</string>
    <string name="face_unlock_set_unlock_password" msgid="5874950853246424756">"Nenosiri • Uso"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Endelea bila kipengele cha Kufungua kwa uso"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7399882488272450182">"Endelea bila alama ya kidole au uso"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Hamna"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Telezesha kidole"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Mchoro"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Nenosiri"</string>
    <string name="unlock_disable_frp_warning_title" msgid="2545569051372893686">"Ungependa kuondoa aina zote za mbinu za kufungua kifaa?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"Ungependa kuondoa ulinzi wasifu?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="6246242612158828147">"Mchoro hulinda simu yako ikipotea au ikiibwa."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2259825377085781801">"Mchoro hulinda simu yako ikipotea au ikiibwa.<xliff:g id="EMPTY_LINE">

</xliff:g>Hatua hii pia hufuta muundo wa alama ya kidole uliohifadhiwa kwenye kifaa chako. Hutaweza kutumia alama ya kidole chako kuthibitisha katika programu."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face" msgid="4699508435412336378">"Mchoro hulinda simu yako ikipotea au ikiibwa.<xliff:g id="EMPTY_LINE">

</xliff:g>Muundo wa uso wako pia utafutwa kabisa kwa usalama. Hutaweza kutumia uso wako kuthibitisha katika programu."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face_fingerprint" msgid="7049706229344804972">"Mchoro hulinda simu yako ikipotea au ikiibwa.<xliff:g id="EMPTY_LINE">

</xliff:g>Hatua hii hufuta muundo wa alama ya kidole uliohifadhiwa kwenye kifaa chako. Muundo wa uso wako pia utafutwa kabisa kwa usalama. Hutaweza kutumia uso wala alama ya kidole chako kuthibitisha katika programu."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="122154942944422284">"PIN hulinda simu yako ikipotea au ikiibwa"</string>
    <string name="unlock_disable_frp_warning_content_pin_authbound_keys" msgid="6497861740382402784">"Utapoteza data iliyohifadhiwa kama vile PIN yako.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Kadi zilizowekewa mipangilio ya kulipa kielektroniki zitaondolewa.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Pochi na programu zingine zinazohitaji mbinu ya kufungua kifaa huenda zisifanye kazi vizuri."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="983373874470746066">"PIN hulinda simu yako ikipotea au ikiibwa.<xliff:g id="EMPTY_LINE">

</xliff:g>Hatua hii pia hufuta muundo wa alama ya kidole uliohifadhiwa kwenye kifaa chako. Hutaweza kutumia alama ya kidole chako kuthibitisha katika programu."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint_authbound_keys" msgid="8930057076658360799">"Utapoteza data iliyohifadhiwa kama vile PIN yako na muundo wa alama ya kidole.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Kadi zilizowekewa mipangilio ya kulipa kielektroniki zitaondolewa.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Pochi na programu zingine zinazohitaji mbinu ya kufungua kifaa huenda zisifanye kazi vizuri."</string>
    <string name="unlock_disable_frp_warning_content_pin_face" msgid="5607150515413131761">"PIN hulinda simu yako ikipotea au ikiibwa.<xliff:g id="EMPTY_LINE">

</xliff:g>Muundo wa uso wako pia utafutwa kabisa kwa usalama. Hutaweza kutumia uso wako kuthibitisha katika programu."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_authbound_keys" msgid="979399855891561038">"Utapoteza data iliyohifadhiwa kama vile PIN yako na muundo wa uso.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Kadi zilizowekewa mipangilio ya kulipa kielektroniki zitaondolewa.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Pochi na programu zingine zinazohitaji mbinu ya kufungua kifaa huenda zisifanye kazi vizuri."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint" msgid="1821792325159866312">"PIN hulinda simu yako ikipotea au ikiibwa.<xliff:g id="EMPTY_LINE">

</xliff:g>Hatua hii hufuta muundo wa alama ya kidole uliohifadhiwa kwenye kifaa chako. Muundo wa uso wako pia utafutwa kabisa kwa usalama. Hutaweza kutumia uso wala alama ya kidole chako kuthibitisha katika programu."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint_authbound_keys" msgid="7019955731206729909">"Utapoteza data iliyohifadhiwa kama vile PIN yako, miundo ya uso na alama ya kidole.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Kadi zilizowekewa mipangilio ya kulipa kielektroniki zitaondolewa.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Pochi na programu zingine zinazohitaji mbinu ya kufungua kifaa huenda zisifanye kazi vizuri."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="6422723907917376210">"Nenosiri hulinda simu yako ikipotea au ikiibwa"</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8899452884016354856">"Nenosiri hulinda simu yako ikipotea au ikiibwa.<xliff:g id="EMPTY_LINE">

</xliff:g>Hatua hii pia hufuta muundo wa alama ya kidole uliohifadhiwa kwenye kifaa chako. Hutaweza kutumia alama ya kidole chako kuthibitisha katika programu."</string>
    <string name="unlock_disable_frp_warning_content_password_face" msgid="1811067332335964495">"Nenosiri hulinda simu yako ikipotea au ikiibwa.<xliff:g id="EMPTY_LINE">

</xliff:g>Muundo wa uso wako pia utafutwa kabisa kwa usalama. Hutaweza kutumia uso wako kuthibitisha katika programu."</string>
    <string name="unlock_disable_frp_warning_content_password_face_fingerprint" msgid="7063649456205159491">"Nenosiri hulinda simu yako ikipotea au ikiibwa.<xliff:g id="EMPTY_LINE">

</xliff:g>Hatua hii hufuta muundo wa alama ya kidole uliohifadhiwa kwenye kifaa chako. Muundo wa uso wako pia utafutwa kabisa kwa usalama. Hutaweza kutumia uso wala alama ya kidole chako kuthibitisha katika programu."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Vipengele vya ulinzi wa kifaa havitafanya kazi bila kipengele chako cha kufunga skrini."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="6542744110902941189">"Vipengele vya ulinzi wa kifaa havitafanya kazi bila mbinu yako ya kufunga skrini.<xliff:g id="EMPTY_LINE">

</xliff:g>Hatua hii pia hufuta muundo wa alama ya kidole uliohifadhiwa kwenye kifaa chako. Hutaweza kutumia alama ya kidole chako kuthibitisha katika programu."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face" msgid="4559917661432267841">"Vipengele vya ulinzi wa kifaa havitafanya kazi bila mbinu yako ya kufunga skrini.<xliff:g id="EMPTY_LINE">

</xliff:g>Muundo wa uso wako pia utafutwa kabisa kwa usalama. Hutaweza kutumia uso wako kuthibitisha katika programu."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face_fingerprint" msgid="3779582301453677644">"Vipengele vya ulinzi wa kifaa havitafanya kazi bila mbinu yako ya kufunga skrini.<xliff:g id="EMPTY_LINE">

</xliff:g>Hatua hii hufuta muundo wa alama ya kidole uliohifadhiwa kwenye kifaa chako. Muundo wa uso wako pia utafutwa kabisa kwa usalama. Hutaweza kutumia uso wala alama ya kidole chako kuthibitisha katika programu."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="6173427638951230842">"Futa"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"<xliff:g id="APP_NAME">%1$s</xliff:g> inapendekeza uweke PIN au nenosiri thabiti na huenda isifanye kazi kama kawaida bila kuwekwa"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"<xliff:g id="APP_NAME">%1$s</xliff:g> inapendekeza uweke PIN au nenosiri jipya na huenda isifanye kazi kama kawaida bila kuwekwa"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"<xliff:g id="APP_NAME">%1$s</xliff:g> inapendekeza uweke mchoro, PIN au nenosiri jipya na huenda isifanye kazi kama kawaida bila kuwekwa"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"<xliff:g id="APP_NAME">%1$s</xliff:g> inapendekeza uweke mbinu mpya ya kufunga skrini"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"Jaribu tena. Jaribio la <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g> kati ya <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="7450322567217745999">"Data yako itafutwa"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"Ukiweka mchoro usio sahihi utakapojaribu tena, data iliyo kwenye kifaa hiki itafutwa"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"Ukiweka PIN isiyo sahihi utakapojaribu tena, data iliyo kwenye kifaa hiki itafutwa"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"Ukiweka nenosiri lisilo sahihi utakapojaribu tena, data iliyo kwenye kifaa hiki itafutwa"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"Ukiweka mchoro usio sahihi utakapojaribu tena, maelezo ya mtumiaji huyu yatafutwa"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"Ukiweka PIN isiyo sahihi utakapojaribu tena, maelezo ya mtumiaji huyu yatafutwa"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"Ukiweka nenosiri lisilo sahihi utakapojaribu tena, maelezo ya mtumiaji huyu yatafutwa"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"Ukiweka mchoro usio sahihi utakapojaribu tena, wasifu wako wa kazini na data iliyomo zitafutwa"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Ukiweka PIN isiyo sahihi utakapojaribu tena, wasifu wako wa kazini na data iliyomo zitafutwa"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Ukiweka nenosiri lisilo sahihi utakapojaribu tena, wasifu wako wa kazini na data iliyomo zitafutwa"</string>
    <string name="lockpassword_password_too_short" msgid="1938086368137797700">"{count,plural, =1{Ni lazima nenosiri liwe na angalau herufi #}other{Ni lazima nenosiri liwe na angalau herufi #}}"</string>
    <string name="lockpassword_password_too_short_all_numeric" msgid="4301294924022401502">"{count,plural, =1{Ikiwa nenosiri linatumia namba pekee, lazima liwe na angalau tarakimu 1}other{Ikiwa nenosiri linatumia namba pekee, lazima liwe na angalau tarakimu #}}"</string>
    <string name="lockpassword_pin_too_short" msgid="8910105226463085689">"{count,plural, =1{Ni lazima PIN iwe na angalau tarakimu #}other{Ni lazima PIN iwe na angalau tarakimu #}}"</string>
    <string name="lockpassword_pin_too_short_autoConfirm_extra_message" msgid="3271351502900762571">"{count,plural, =1{Ni lazima PIN iwe na angalau tarakimu #, lakini PIN yenye tarakimu {minAutoConfirmLen} inapendekezwa kwa ajili ya usalama zaidi}other{Ni lazima PIN iwe na angalau tarakimu #, lakini PIN yenye tarakimu {minAutoConfirmLen} inapendekezwa kwa usalama zaidi}}"</string>
    <string name="lockpassword_password_too_long" msgid="1940345313260498308">"{count,plural, =1{Ni lazima nenosiri liwe na herufi chini ya #}other{Ni lazima nenosiri liwe na herufi chini ya #}}"</string>
    <string name="lockpassword_pin_too_long" msgid="1678212054564388576">"{count,plural, =1{Ni lazima nenosiri liwe na tarakimu chini ya #}other{Ni lazima nenosiri liwe na tarakimu chini ya #}}"</string>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"Msimamizi wa kifaa haruhusu utumie PIN uliyotumia hivi majuzi"</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"Hali hii haiwezi kujumuisha kibambo kisichoruhusiwa"</string>
    <string name="lockpassword_password_requires_letters" msgid="7058340182953750553">"{count,plural, =1{Ni lazima nenosiri liwe na angalau herufi 1}other{Ni lazima nenosiri liwe na angalau herufi #}}"</string>
    <string name="lockpassword_password_requires_lowercase" msgid="3286121470522077547">"{count,plural, =1{Ni lazima nenosiri liwe na angalau herufi 1 ndogo}other{Ni lazima nenosiri liwe na angalau herufi ndogo #}}"</string>
    <string name="lockpassword_password_requires_uppercase" msgid="720312543910397772">"{count,plural, =1{Ni lazima nenosiri liwe na angalau herufi 1 kubwa}other{Ni lazima nenosiri liwe na angalau herufi # kubwa}}"</string>
    <string name="lockpassword_password_requires_numeric" msgid="3886918493600507548">"{count,plural, =1{Ni lazima nenosiri liwe na angalau tarakimu 1}other{Ni lazima nenosiri liwe na angalau tarakimu #}}"</string>
    <string name="lockpassword_password_requires_symbols" msgid="2904870551002210131">"{count,plural, =1{Ni lazima nenosiri liwe na angalau alama 1 maalum}other{Ni lazima nenosiri liwe na angalau alama # maalum}}"</string>
    <string name="lockpassword_password_requires_nonletter" msgid="1185342065898300006">"{count,plural, =1{Ni lazima nenosiri liwe na angalau herufi 1 ambayo si alfabeti}other{Ni lazima nenosiri liwe na angalau herufi # ambazo si alfabeti}}"</string>
    <string name="lockpassword_password_requires_nonnumerical" msgid="389687423482993365">"{count,plural, =1{Ni lazima nenosiri liwe na angalau herufi 1 ambayo si tarakimu}other{Ni lazima nenosiri liwe na angalau herufi # ambazo si tarakimu}}"</string>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"Msimamizi wa kifaa haruhusu kutumia nenosiri ulilotumia hivi majuzi"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Haturuhusi mpangilio wa kupanda, kushuka au kujirudia kwa tarakimu"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Thibitisha"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Futa"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Mbinu ya kufunga skrini tayari imebadilishwa. Jaribu tena ukitumia mbinu mpya ya kufunga skrini."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Ghairi"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Endelea"</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Programu za msimamizi wa kifaa"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"Hakuna programu zinazotumika"</string>
    <string name="number_of_device_admins" msgid="3402909995362162876">"{count,plural, =1{Programu # inatumika}other{Programu # zinatumika}}"</string>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Kipengele cha kutathmini hali ya kuaminika"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Ili utumie, weka mbinu ya kufunga skrini kwanza"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Hamna"</string>
    <string name="manage_trust_agents_summary_on" msgid="3302574418419446146">"{count,plural, =1{Kipengele 1 kinachotumika cha kutathmini hali ya kuaminika}other{Vipengele # vinavyotumika vya kutathmini hali ya kuaminika}}"</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">"Je, ungependa kuoanisha na <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_group_late_bonding" msgid="3047893658902159692">"Thibitisha ili uweke kifaa chako cha pili cha sauti"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Msimbo wa kuoanisha Bluetooth"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Andika msimbo wa kuoanisha kisha ubonyeze \"Return\" au \"Enter\""</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"PIN inajumlisha herufi au ishara"</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Kwa kawaida 0000 au 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Lazima iwe na tarakimu 16"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Unawezahitaji pia kucharaza PIN hii kwenye kifaa kingine."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Unaweza pia kuhitaji kucharaza nenosiri hili kwenye kifaa kingine."</string>
    <string name="bluetooth_paring_group_msg" msgid="2455293929036668131">"Thibitisha ili uunganishe na kifaa cha sauti"</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Ruhusu ufikiaji wa anwani na historia ya simu ulizopiga"</string>
    <string name="bluetooth_pairing_phonebook_toggle_text" msgid="2474015367387690034">"Ruhusu pia ufikiaji wa anwani na rekodi ya simu zilizopigwa"</string>
    <string name="bluetooth_pairing_phonebook_toggle_details" msgid="1367197978487212581">"Maelezo yatatumiwa kwa matangazo ya simu na zaidi"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Haikuweza kuunganisha kwa <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Vifaa vinavyopatikana"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Unganisha"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Tenganisha"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Oanisha kisha uunganishe"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="7326727272747345476">"Wakati Bluetooth imewashwa, kifaa chako kinaweza kuwasiliana na vifaa vingine vyenye Bluetooth vilivyo karibu"</string>
    <string name="bluetooth_empty_list_bluetooth_off_auto_on_available" msgid="5833847615853525971">"Wakati Bluetooth imewashwa, kifaa chako kinaweza kuwasiliana na vifaa vingine vyenye Bluetooth vilivyo karibu. Vipengele kama vile Kutuma Haraka, Tafuta Kifaa Changu na mahali kifaa kilipo hutumia Bluetooth."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="786648535600075223">"Wakati Bluetooth imewashwa, kifaa chako kinaweza kuwasiliana na vifaa vingine vyenye Bluetooth vilivyo karibu.\n\nIli kuboresha hali ya matumizi ya kifaa, programu na huduma bado zinaweza kutafuta vifaa vilivyo karibu wakati wowote, hata wakati umezima Bluetooth. Hali hii inaweza kutumika, kwa mfano, kuboresha huduma na vipengele vinavyohusiana na mahali. Unaweza kubadilisha mipangilio hii katika mipangilio ya kutafuta Bluetooth."</string>
    <string name="bluetooth_scanning_on_info_message_auto_on_available" msgid="5047787966768730069">"Wakati Bluetooth imewashwa, kifaa chako kinaweza kuwasiliana na vifaa vingine vyenye Bluetooth vilivyo karibu. Vipengele kama vile Kutuma Haraka, Tafuta Kifaa Changu na mahali kifaa kilipo hutumia Bluetooth.\n\nProgramu na huduma bado zinaweza kutafuta vifaa vilivyo karibu wakati wowote, hata wakati Bluetooth imezimwa. Mipangilio hii inaweza kutumiwa, kwa mfano, kuboresha vipengele na huduma zinazotumia maelezo ya mahali. Unaweza kubadilisha hali hii kwenye mipangilio ya Kutafuta Bluetooth."</string>
    <string name="bluetooth_scan_change" msgid="1744636222637390367">"Badilisha"</string>
    <string name="device_details_title" msgid="1155622417516195481">"Maelezo ya kifaa"</string>
    <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"Mipangilio ya kibodi"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Anwani ya Bluetooth ya kifaa chako: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_multuple_devices_mac_address" msgid="4974301550897923376">"Anwani ya Bluetooth ya kifaa:\n<xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"Ungependa kusahau kifaa?"</string>
    <string name="remove_association_button" msgid="5004208145998061135">"Ondoa uhusiano"</string>
    <string name="bluetooth_companion_app_remove_association_dialog_title" msgid="1344518601377991897">"Ungependa kutenganisha programu?"</string>
    <string name="bluetooth_companion_app_body" msgid="8442643629075687761">"Programu ya <xliff:g id="APP_NAME">%1$s</xliff:g> haitaunganisha tena kwenye <xliff:g id="DEVICE_NAME">%2$s</xliff:g> yako"</string>
    <string name="device_details_leaudio_toggle_summary" msgid="7684848254433230809">"Ya majaribio. Huboresha sauti."</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Sahau kifaa"</string>
    <string name="bluetooth_companion_app_remove_association_confirm_button" msgid="76323555527926915">"Tenganisha programu"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Kima cha juu zaidi cha vifaa vya sauti vya Bluetooth vilivyounganishwa"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Chagua kima cha juu zaidi cha vifaa vya sauti vya Bluetooth vilivyounganishwa"</string>
    <string name="nfc_stack_debuglog_title" msgid="2926748386805740609">"Kumbukumbu ya utatuzi wa rafu za NFC"</string>
    <string name="nfc_stack_debuglog_summary" msgid="7333205107551132121">"Ongeza kiwango cha kuweka kumbukumbu ya rafu za NFC"</string>
    <string name="nfc_verbose_vendor_log_title" msgid="5554505631122964628">"Kumbukumbu ya kina ya utatuzi ya mtoa huduma"</string>
    <string name="nfc_verbose_vendor_log_summary" msgid="3049128322855928507">"Jumuisha kumbukumbu za ziada za mtoa huduma mahususi kwa kifaa katika ripoti za hitilafu ambazo huenda zikawa na taarifa ya faragha."</string>
    <string name="nfc_snoop_log_title" msgid="1576197495976952388">"Kumbukumbu isiyochujwa ya NFC NCI"</string>
    <string name="nfc_snoop_log_summary" msgid="3988383328800163180">"Nasa vifurushi vya maelezo vya NFC ambavyo huenda vikawa na taarifa ya faragha."</string>
    <string name="nfc_reboot_dialog_title" msgid="2033983438635768169">"Ungependa kuzima kisha uwashe kifaa?"</string>
    <string name="nfc_reboot_dialog_message" msgid="4929353168157966992">"Uwekaji maelezo ya kumbukumbu ya NFC ni kwa madhumuni ya usanidi pekee. Vilevile data ya NFC inajumuishwa katika ripoti za hitilafu ambazo huenda zikawa na taarifa ya faragha. Zima kisha uwashe kifaa chako ili ubadili mipangilio hii."</string>
    <string name="nfc_reboot_dialog_confirm" msgid="4769763632008584567">"Zima kisha uwashe"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Tuma"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"kioo"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Washa kuonyesha skrini bila kutumia waya"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"Hakuna vifaa vilivyopatikana karibu."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Inaunganisha"</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Vimeunganishwa"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"Vinavyotumika"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Hakipatikani"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Chaguo za uonyeshaji bila kutumia waya"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Sahau"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Imekamilika"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Jina"</string>
    <string name="wifi_band_24ghz" msgid="7322286660245127384">"GHz 2.4"</string>
    <string name="wifi_band_5ghz" msgid="7995204987245404797">"GHz 5"</string>
    <string name="wifi_band_6ghz" msgid="8166833829829455339">"GHz 6"</string>
    <string name="wifi_sign_in_button_text" msgid="8483892122845654850">"Ingia katika akaunti"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Fungua tovuti"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"Zimesalia <xliff:g id="REMAINING_TIME">%1$s</xliff:g>"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Muda wake utaisha <xliff:g id="EXPIRY_TIME">%1$s</xliff:g>"</string>
    <string name="tx_link_speed" msgid="3071955184703668113">"Mbps <xliff:g id="TRANSMIT_LINK_SPEED">%1$d</xliff:g>"</string>
    <string name="rx_link_speed" msgid="6292229178855567783">"Mbps <xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g>"</string>
    <string name="link_speed" msgid="931786745741016446">"Mbps <xliff:g id="LINK_SPEED">%1$d</xliff:g>"</string>
    <string name="wifi_ask_enable" msgid="6860056048266810769">"<xliff:g id="REQUESTER">%s</xliff:g> inataka kuwasha Wi-Fi"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"<xliff:g id="REQUESTER">%s</xliff:g> inataka kuzima Wi-Fi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Thibitisha msimbo wa baiti wa programu zinazoweza kutatuliwa"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Ruhusu ART kuthibitisha msimbo wa baiti wa programu zinazoweza kutatuliwa"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Onyesha kiwango cha kuonyesha upya"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Onyesha kiwango cha kuonyesha upya cha sasa cha skrini"</string>
    <string name="show_hdr_sdr_ratio" msgid="4188007289024955585">"Onyesha uwiano wa HDR/SDR"</string>
    <string name="show_hdr_sdr_ratio_summary" msgid="986292785096013733">"Onyesho uwiano wa sasa wa HDR/SDR"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Hitaji kifaa kifunguliwe ili kipengele cha NFC kitumike"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Programu iko tayari kusambaza maudhui kupitia NFC"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Imezimwa"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Haipatikani kwa sababu NFC imezimwa"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"Unapowasha kipengele hiki, unaweza kutuma maudhui ya programu kwenye kifaa kingine kinachoweza kutumia NFC kwa kuviweka vifaa pamoja. Kwa mfano, unaweza kutuma kurasa za wavuti, video za YouTube, anwani na mengineyo.\n\nWeka tu vifaa pamoja (kwa kuvigusisha sehemu za nyuma) na uguse skrini yako. Programu itabaini kile kitatumwa."</string>
    <string name="wifi_settings" msgid="8313301946393559700">"Wi-Fi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"Tumia Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"Mipangilio ya Wi-Fi"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Chagua Wi-Fi"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"Inawasha Wi-Fi..."</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"Inazima Wi-Fi..."</string>
    <string name="wifi_error" msgid="4903954145386086899">"Hitilafu"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"Mitabendi ya GHz 5 haipatikani katika nchi hii"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"Hali ya ndegeni imewashwa"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Niarifu mitandao ya umma inapopatikana"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Tuma arifa wakati mtandao wa umma wenye ubora wa juu unapatikana"</string>
    <string name="wifi_allow_wep_networks" msgid="8772342993235292010">"Ruhusu mitandao ya WEP"</string>
    <string name="wifi_allow_wep_networks_summary" msgid="3033397893296724615">"WEP ni itifaki ya usalama ya zamani ambayo si salama sana"</string>
    <string name="wifi_allow_wep_networks_summary_carrier_not_allow" msgid="6298103289728210026">"Mtoa huduma wako haruhusu mitandao ya WEP kwa sababu si salama sana"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Washa Wi‑Fi kiotomatiki"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"Wi-Fi itaanza kutumika tena mitandao iliyohifadhiwa ya ubora wa juu itakapopatikana, kama vile mtandao wa nyumbani"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Haipatikani kwa sababu umezima huduma za mahali. Washa "<annotation id="link">"huduma za mahali"</annotation>"."</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Sakinisha vyeti"</string>
    <string name="wifi_scan_notify_text" msgid="7163137260385995873">"Ili uboreshe usahihi wa kutambua mahali, programu na huduma zinaweza kutafuta mitandao ya Wi‑Fi wakati wowote, hata wakati umezima Wi‑Fi. Hili linaweza kutumika, kwa mfano, kuboresha huduma na vipengee vinavyohusiana na mahali. Unaweza kubadilisha hili katika <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>mipangilio ya kutafuta Wi-Fi<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="7439201783168213149">"Ili kuboresha usahihi wa data ya mahali, washa kipengele cha kutafuta Wi-Fi katika <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>mipangilio ya kutafuta Wi-Fi<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Tumia data ya mtandao wa simu kiotomatiki"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Tumia data ya mtandao wa simu wakati Wi-Fi haina muunganisho wa intaneti. Huenda ukalipia data utakayotumia."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Ongeza mtandao"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"Mapendeleo ya Wi‑Fi"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"Wi‑Fi hutumika tena kiotomatiki"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"Hutaunganishwa tena kwenye Wi‑Fi kiotomatiki"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"Wi‑Fi Moja kwa Moja"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Ili kutazama mitandao inayopatikana, washa Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="2448010040478321376">"Inatafuta mitandao…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Huna ruhusa ya kubadilisha mtandao wa Wi -Fi."</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Ungependa kutafuta Wi-Fi?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"Ili uwashe Wi‑Fi kiotomatiki, unatakiwa kuwasha kipengele cha kutafuta Wi‑Fi kwanza."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"Utafutaji wa Wi-Fi huruhusu programu na huduma zitafute mitandao ya Wi-Fi wakati wowote, hata wakati umezima Wi-Fi. Hali hii inaweza kutumika, kwa mfano, kuboresha huduma na vipengele vinavyohusiana na mahali."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Washa"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"Umewasha utafutaji wa Wi‑Fi"</string>
    <string name="wifi_settings_warning_wep_network" msgid="2655077013800385646">"Mtandao huu unatumia itifaki ya usalama ya zamani ambayo si salama sana"</string>
    <string name="wifi_settings_wep_networks_blocked_title" msgid="8337700496544833669">"<xliff:g id="NAME">%1$s</xliff:g> imezuiwa"</string>
    <string name="wifi_settings_wep_networks_summary_toggle_off" msgid="1113138364046142949">"Mtandao huu unatumia itifaki ya usalama ya zamani, inayojulikana kama WEP, ambayo si salama sana. Ili uunganishe hata hivyo, ruhusu mitandao ya WEP."</string>
    <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Mtoa huduma wako hakuruhusu kuunganisha kwenye mtandao huu kwa sababu unatumia itifaki ya usalama ya zamani ambayo si salama sana"</string>
    <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Ruhusu WEP"</string>
    <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Funga"</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">"Chaguo za kina"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Chaguo za Kina za Orodha Kunjuzi"</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"panua"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Jina la mtandao"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Weka Kitambulisho cha Mtandao (SSID)"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Usalama"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Mtandao uliofichwa"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"Ikiwa kisambaza data chako hakionyeshi Kitambulisho cha mtandao lakini ungependa kiunganishwe baadaye, unaweza kuficha mtandao.\n\nHali hii inaweza kusababisha hatari ya usalama kwa sababu simu yako itaonyesha mara kwa mara ishara yake ili ipate mtandao.\n\nHatua ya kuweka mtandao kuwa katika hali iliyofichwa haitabadilisha mipangilio ya kisambaza data chako."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Nguvu za mawimbi"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Hali"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Kasi ya kutuma kiungo"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Kasi ya kupokea kiungo"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Kasi ya muunganisho"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Masafa"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"Anwani ya IP"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Imehifadhiwa kupitia"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"Kitambulisho cha <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"Mtindo wa EAP"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"Uthibitisho wa awamu ya pili"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"Cheti cha CA"</string>
    <string name="wifi_eap_min_tls_ver" msgid="174023604103299457">"Kiwango cha chini cha toleo la TLS"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Hali ya Cheti Mtandaoni"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Kikoa"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Cheti cha mtumiaji"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Kitambulisho"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Kitambulisho kisichojulikana"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Nenosiri"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Onyesha nenosiri"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"Bendi ya GHz 2.4"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"Bendi ya GHz 5.0 (inapendelewa)"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"Mipangilio ya IP"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Faragha"</string>
    <string name="wifi_privacy_mac_settings" msgid="3188060664478313363">"MAC"</string>
    <string name="wifi_privacy_device_name_settings" msgid="3699130177041345275">"Jina la kifaa"</string>
    <string name="wifi_privacy_send_device_name_toggle_title" msgid="1228107313152880073">"Tuma jina la kifaa"</string>
    <string name="wifi_privacy_send_device_name_toggle_summary" msgid="5995365836332817655">"Ruhusu mtandao ufikie jina la kifaa hiki"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Usajili"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Angalia au ubadilishe usajili"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Anwani ya MAC kwa nasibu"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Ongeza kifaa"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Weka katikati msimbo wa QR ulio hapa chini ili uongeze kifaa kwenye “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"Changanua msimbo wa QR"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Weka katikati msimbo wa QR ulio hapa chini ili uunganishe kwenye “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Unganisha Wi-Fi kwa kuchanganua msimbo wa QR"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"Shiriki Wi‑Fi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Changanua msimbo huu wa QR kwa kutumia kifaa kingine ili uunganishe “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Changanua msimbo huu wa QR ili uunganishe kwenye “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Jaribu tena. Tatizo hili likiendelea, wasiliana na kampuni iliyotengeneza kifaa"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Hitilafu fulani imetokea"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Hakikisha kuwa umechomeka kifaa, umekichaji na umekiwasha"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Hakikisha kuwa umechomeka kifaa, umekichaji na umekiwasha. Tatizo hili likiendelea, wasiliana na kampuni iliyotengeneza kifaa"</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"Huwezi kuongeza “<xliff:g id="SSID">%1$s</xliff:g>” kwenye kifaa hiki"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Jaribu kusogeza kifaa karibu na kisambaza data/mlango wa mtandao wako wa Wi-Fi"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Angalia nenosiri na ujaribu tena"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Wasiliana na mtengenezaji wa kifaa"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Angalia muunganisho na ujaribu tena"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Chagua mtandao"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Ili uunganishe kifaa chako, chagua mtandao"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Ungependa kuongeza kifaa hiki kwenye “<xliff:g id="SSID">%1$s</xliff:g>”?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"Wi‑Fi imeshirikiwa na kifaa"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Ongeza kifaa kingine"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Chagua mtandao tofauti"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Imeshindwa kuongeza kifaa"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Imepata kifaa"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"Inashiriki Wi‑Fi na kifaa hiki…"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Inaunganisha…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Shiriki mtandaopepe"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="5246641326066972419">"Thibitisha kuwa ni wewe"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"Nenosiri la Wi-Fi: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Nenosiri la mtandaopepe: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Unganisha kiotomatiki"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Ruhusu iunganishe kwenye mtandao huu unapokuwa karibu"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Ongeza kifaa"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Tumia msimbo wa QR ili uongeze kifaa kwenye mtandao huu"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"Msimbo wa QR si muundo sahihi"</string>
    <string name="retry" msgid="7542103800274026915">"Jaribu tena"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Shiriki na watumiaji wengine wa kifaa"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(hujabadilisha)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Tafadhali chagua"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(Imeongeza vyeti vingi)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Tumia vyeti vya mfumo"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Usitoe"</string>
    <string name="wifi_trust_on_first_use" msgid="7488431582505858774">"Amini wakati wa matumizi ya kwanza"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Jina la mtandao ni refu sana."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Lazima ubainishe kikoa."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Inahitaji cheti."</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"Ili kuboresha usahihi wa mahali na kwa madhumuni mengine, <xliff:g id="APP_NAME">%1$s</xliff:g> inataka kuwasha ukaguaji mitandao, hata wakati Wi-Fi imezimwa.\n\nJe, ungependa kuruhusu programu zote ambazo zingependa kukagua ziweza kufanya hivyo?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="4903345360745717385">"Ili kuboresha usahihi wa mahali na kwa madhumuni mengine, programu isiyojulikana inataka kuwasha utafutaji wa mtandao, hata wakati Wi-Fi imezimwa.\n\nUtatoa ruhusa kwa programu zinazotaka kutafuta?"</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Ruhusu"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Kataa"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Mtandao huu hauna intaneti. Utaendelea kuutumia?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Huenda baadhi ya programu na huduma zisifanye kazi kwa sababu ya muunganisho hafifu. Tumia tu?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"Usiulizie mtandao huu tena"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"Muunganisho wa Wi-Fi umekatika"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"Unaweza kutumia data ya mtandao wa simu wakati wowote Wi-Fi inapokuwa na muunganisho dhaifu. Huenda ukalipia ada ya kutumia data."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Tumia data ya mtandao wa simu"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Endelea kutumia Wi-Fi"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Usionyeshe tena"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Unganisha"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Imeunganishwa kwenye <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Inaunganisha…"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Imeshindwa kuunganisha kwa mtandao"</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Mtandao hauko karibu"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Sahau"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Rekebisha"</string>
    <string name="wifi_save" msgid="2312643132472226807">"Hifadhi"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Imeshindwa kuhifadhi mtandao"</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Ghairi"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Ungependa kusahau mtandao?"</string>
    <string name="wifi_saved_access_points_summary" msgid="6637163320524940353">"{count,plural, =1{Mtandao 1}other{Mitandao #}}"</string>
    <string name="wifi_saved_passpoint_access_points_summary" msgid="8939933724918673785">"{count,plural, =1{Aina 1 ya usajili}other{Aina # za usajili}}"</string>
    <string name="wifi_saved_all_access_points_summary" msgid="2335870101156113858">"{count,plural, =1{Aina 1 ya mtandao na usajili}other{Aina # za mitandao na usajili}}"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"Anwani ya MAC ya kifaa"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Anwani ya MAC kwa nasibu"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Anwani ya MAC kwa nasibu (mara ya mwisho kutumika)"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Maelezo ya mtandao"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Mfano wa kijimtandao"</string>
    <string name="wifi_type_title" msgid="2174893488722015838">"Aina"</string>
    <string name="wifi_details_dns" msgid="273231528073312579">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="1913151339341722443">"Anwani za IPv6"</string>
    <string name="hotspot_device_details_category" msgid="3110651914598697220">"Maelezo ya kifaa cha mtandao pepe"</string>
    <string name="hotspot_device_details_internet_source" msgid="1563266599673281875">"Chanzo cha Intaneti"</string>
    <string name="internet_source_wifi" msgid="6952593095166435179">"Wi-Fi"</string>
    <string name="internet_source_mobile_data" msgid="877403889449201789">"Data ya mtandao wa simu"</string>
    <string name="internet_source_ethernet" msgid="8338472576454100966">"Ethaneti"</string>
    <string name="hotspot_battery_charging_summary" msgid="6690892148553288457">"<xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g> ‑ Inachaji"</string>
    <string name="hotspot_connection_category" msgid="4320380513982923556">"Muunganisho wa mtandao pepe"</string>
    <string name="hotspot_connection_strength" msgid="87359986943768421">"Uthabiti wa muunganisho"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Mitandao iliyohifadhiwa"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Usajili"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Mitandao mingine"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Andika anwani ya IP halali."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Tafadhali charaza anwani halali ya lango."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Tafadhali charaza anwani halali ya DNS."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Andika urefu wa kiambishi awali cha mtandao kati ya 0 na 32."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS ya kwanza (isipokuwa ikibatilishwa na DNS ya Faragha)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS ya pili (isipokuwa ikibatilishwa na DNS ya Faragha)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Lango"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Urefu wa kiambishi awali cha mtandao"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"Wi-Fi Moja kwa moja"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Tafuta vifaa"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Inatafuta…"</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Badilisha jina la kifaa"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Vifaa vinavyoshirikiana"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Vikundi vinavyokumbukwa"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Haikuweza kuunganisha."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Imeshindwa kubadili jina la kifaa."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Tenganisha?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"Ukitenganisha, muunganisho wako na <xliff:g id="PEER_NAME">%1$s</xliff:g> utakoma."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="4490648217799144078">"Ukitenganisha, muunganisho wako na <xliff:g id="PEER_NAME">%1$s</xliff:g> na vifaa vingine <xliff:g id="PEER_COUNT">%2$s</xliff:g> utakoma."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="8476985132989357041">"Ghairi mwaliko?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"Je, unataka kughairi mwaliko wa kuungana na <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="4880242270742385699">"Sahau kikundi hiki?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"Mtandaopepe wa Wi-Fi"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"Haishiriki intaneti au maudhui na vifaa vingine"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"Hujaweka nenosiri lolote"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Jina la mtandaopepe"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Nenosiri la mtandaopepe"</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Zima mtandaopepe kiotomatiki"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Wakati hamna vifaa vilivyounganishwa"</string>
    <string name="wifi_hotspot_maximize_compatibility" msgid="6494125684420024058">"Panua uoanifu"</string>
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary" msgid="383355687431591441">"Husaidia vifaa vingine kupata mtandao pepe huu. Hupunguza kasi ya muunganisho wa mtandao pepe."</string>
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary" msgid="3579549223159056533">"Husaidia vifaa vingine kupata mtandao pepe huu. Huongeza matumizi ya betri."</string>
    <string name="wifi_hotspot_speed_title" msgid="8629448084180512685">"Kasi na uoanifu"</string>
    <string name="wifi_hotspot_speed_summary_2g" msgid="5063438001736234858">"GHz 2.4 / Unatumika kwenye vifaa vingi"</string>
    <string name="wifi_hotspot_speed_summary_5g" msgid="6221158936983135040">"GHz 5 / Unatumika kwenye vifaa vingi"</string>
    <string name="wifi_hotspot_speed_summary_6g" msgid="8863992901226595544">"GHz 6 / Unatumika kwenye vifaa vichache"</string>
    <string name="wifi_hotspot_speed_summary_2g_and_5g" msgid="5931052946168943750">"GHz 2.4 na 5 / Unatumika kwenye vifaa vingi"</string>
    <string name="wifi_hotspot_speed_intro" msgid="6973482196363758925">"Chagua masafa ya mtandao wako pepe. Masafa yanaathiri kasi ya muunganisho na aina za vifaa vinavyoweza kufikia mtandao wako pepe."</string>
    <string name="wifi_hotspot_speed_category" msgid="5265655850463630286">"Masafa yanayopendelewa"</string>
    <string name="wifi_hotspot_speed_2g" msgid="3400600834257664480">"GHz 2.4"</string>
    <string name="wifi_hotspot_speed_2g_summary" msgid="6930273933810520155">"Kasi za chini. Unatumika kwenye vifaa vingi."</string>
    <string name="wifi_hotspot_speed_5g" msgid="4058116867148848395">"GHz 5"</string>
    <string name="wifi_hotspot_speed_5g_summary" msgid="562987935924535694">"Kasi za juu. Unatumika kwenye vifaa vingi."</string>
    <string name="wifi_hotspot_speed_2g_5g" msgid="9192756255938408285">"GHz 2.4 na 5"</string>
    <string name="wifi_hotspot_speed_2g_5g_summary" msgid="8104575293617700173">"Kasi za juu. Mtandao pepe huu wa bendi mbili unatumika kwenye vifaa vingi."</string>
    <string name="wifi_hotspot_speed_6g" msgid="3787697484862730500">"GHz 6"</string>
    <string name="wifi_hotspot_speed_6g_summary" msgid="8675262219242174548">"Kasi za juu zaidi. Unatumika kwenye vifaa vingi."</string>
    <string name="wifi_hotspot_speed_summary_unavailable" msgid="7276080644693388756">"Haipatikani katika nchi au eneo uliko"</string>
    <string name="wifi_hotspot_speed_footer" msgid="8846939503916795002">"Iwapo masafa unayopendelea hayapatikani, mtandao wako pepe unaweza kutumia masafa tofauti. Mipangilio ya usalama wa mtandao pepe inaweza kubadilika ukibadilisha masafa."</string>
    <string name="wifi_hotspot_security_summary_unavailable" msgid="117582979310345853">"Haitumii GHz 6"</string>
    <string name="wifi_hotspot_security_footer" msgid="4608329688744949796">"Mipangilio ya usalama huenda ikabadilika ukibadilisha masafa ya mtandao pepe"</string>
    <string name="wifi_hotspot_instant_title" msgid="7052526695338853703">"Mtandao pepe papo hapo"</string>
    <string name="wifi_hotspot_instant_summary_on" msgid="3142749148673081288">"Umewasha"</string>
    <string name="wifi_hotspot_instant_summary_off" msgid="8594065628453795615">"Umezima"</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Inawezesha mtandaopepe…"</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Inazima intaneti..."</string>
    <string name="wifi_tether_carrier_unsupport_dialog_title" msgid="3089432578433978073">"Kipengele cha kusambaza mtandao hakipatikani"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_content" msgid="5920421547607921112">"Wasiliana na mtoa huduma wako ili upate maelezo"</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> inatumika"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"AndroidHotspot"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Ungependa kuhifadhi mtandao huu?"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Inahifadhi…"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Imehifadhiwa"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Imeshindwa kuhifadhi. Jaribu tena."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Ungependa kuhifadhi mitandao?"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Inahifadhi mitandao <xliff:g id="NUMBER">%d</xliff:g>…"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Mitandao imehifadhiwa"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"Kupiga simu kupitia Wi-Fi"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Panua eneo la huduma kwa kupiga simu kupitia Wi‑Fi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Washa kupiga simu kupitia Wi‑Fi ili upanue eneo la huduma"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Mapendeleo ya kupiga simu"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Mapendeleo ya kupiga simu"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Mapendeleo ya mitandao ya ng\'ambo"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Mapendeleo ya mitandao ya ng\'ambo"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"Wi-Fi"</item>
    <item msgid="8622872038388687383">"Mtandao wa simu"</item>
    <item msgid="3027927219952052398">"Wi-Fi pekee"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"Wi-Fi"</item>
    <item msgid="7566603075659706590">"Mtandao wa simu"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"Ikiwa Wi-Fi haipatikani, tumia mtandao wa simu"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"Ikiwa mtandao wa simu haupatikani, tumia Wi-Fi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Piga simu kupitia WI-FI. Ikiwa Wi-Fi haipatikani, simu itakatika."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"Wakati kipengele cha kupiga simu kupitia Wi-Fi kimewashwa, simu yako inaweza kuelekeza simu kupitia mitandao ya Wi-Fi au mtandao wa kampuni inayokupa huduma za simu, kutegemea mapendeleo yako na mawimbi yaliyo thabiti zaidi. Kabla ya kuwasha kipengele hiki, angalia ada na maelezo mengine kutoka kwenye kampuni inayokupa huduma za simu.<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">"Anwani ya dharura"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Inatumika kama anwani ya mahali ulipo ikiwa utapiga simu ukitumia Wi‑Fi"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Pata maelezo zaidi"</annotation>" kuhusu vipengele vya DNS ya Faragha"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Imewashwa"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Washa Huduma ya Kupiga Simu kupitia Wi-Fi"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Washa kipengele cha kupiga simu kupitia Wi-Fi"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"Imeondolewa kwenye <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="sound_settings" msgid="7622986039384531304">"Milio na mitetemo"</string>
    <string name="account_settings" msgid="255404935489127404">"Akaunti"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Akaunti za wasifu wa kazini - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Akaunti za wasifu wa binafsi"</string>
    <string name="accessibility_category_clone" msgid="7893383448944567885">"Akaunti za wasifu wa kloni"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Akaunti ya kazini - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Akaunti ya binafsi- <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Tafuta"</string>
    <string name="display_settings" msgid="7197750639709493852">"Skrini"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Skrini ijizungushe kiotomatiki"</string>
    <string name="auto_rotate_option_off" msgid="2788096269396290731">"Imezimwa"</string>
    <string name="auto_rotate_option_on" msgid="5776678230808498171">"Imewashwa"</string>
    <string name="auto_rotate_option_face_based" msgid="3438645484087953174">"Imewashwa - Inayolenga nyuso"</string>
    <string name="auto_rotate_switch_face_based" msgid="9116123744601564320">"Utambuzi wa Nyuso"</string>
    <string name="auto_rotate_link_a11y" msgid="5146188567212233286">"Pata maelezo zaidi kuhusu kuzungusha skrini kiotomatiki"</string>
    <string name="screen_resolution_title" msgid="2690518693139811486">"Ubora wa skrini"</string>
    <string name="screen_resolution_option_high" msgid="2617496842852992853">"Ubora wa juu"</string>
    <string name="screen_resolution_option_full" msgid="2694003735219114186">"Ubora kamili"</string>
    <string name="screen_resolution_footer" msgid="6772341522952795647">"Ubora kamili wa skrini hutumia zaidi betri yako. Kubadili ubora wa skrini yako kunaweza kusababisha baadhi ya programu zizime kisha ziwake."</string>
    <string name="screen_resolution_selected_a11y" msgid="6158451180032224977">"Umechaguliwa"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Rangi"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Asili"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Imeongezwa Rangi"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Imekolezwa"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Inayojirekebisha"</string>
    <string name="brightness" msgid="6216871641021779698">"Kiwango cha mwangaza"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Mwangaza unaojirekebisha"</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"Itarekebisha mwangaza wa skrini kiotomatiki ili uendane na mazingira na shughuli zako. Unaweza kusogeza kitelezi mwenyewe ili kusaidia kipengele cha mwangaza unaojirekebisha kijifunze mapendeleo yako."</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"Umewashwa"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Kimezimwa"</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Ulinganifu wa weupe wa skrini"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="fold_lock_behavior_title" msgid="786228803694268449">"Endelea kutumia programu ukiwa umekunja"</string>
    <string name="disable_game_default_frame_rate_title" msgid="3712908601744143753">"Zima kasi chaguomsingi ya picha ya michezo"</string>
    <string name="disable_game_default_frame_rate_summary" msgid="4436762704707434225">"Zima kipengele cha kuweka kikomo cha kasi ya picha ya juu ya michezo iwe Hz <xliff:g id="FRAME_RATE">%1$d</xliff:g>."</string>
    <string name="peak_refresh_rate_title" msgid="2056355754210341011">"Onyesho laini"</string>
    <string name="peak_refresh_rate_summary" msgid="3212309985294885790">"Hupandisha kiotomatiki kiwango cha kuonyesha upya hadi Hz <xliff:g id="ID_1">%1$d</xliff:g> kwa baadhi ya maudhui. Huongeza matumizi ya betri."</string>
    <string name="force_high_refresh_rate_toggle" msgid="3325789621928312050">"Lazimisha kiwango cha juu cha kuonyesha upya"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Kiwango cha juu kabisa cha kuonyesha upya kwa utendakazi wa mguso ulioboreshwa na ubora wa uhuishaji. Huongeza matumizi ya betri."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Utashi wa skrini"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Inahitaji idhini ya kufikia kamera"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5822591289468803691">"Ruhusa ya kufikia kamera inahitajika kwa ajili ya utashi wa skrini. Gusa ili udhibiti ruhusa za Huduma za Kubadilisha Kifaa Upendavyo"</string>
    <string name="adaptive_sleep_manage_permission_button" msgid="1404510197847664846">"Dhibiti ruhusa"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Huzuia skrini yako kuzima ikiwa unaiangalia"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"Kipengele cha utashi wa skrini hutumia kamera ya mbele ili kuona ikiwa kuna mtu anayeangalia skrini. Kipengele hiki hufanya kazi kwenye kifaa na picha hazihifadhiwi wala kutumwa kwa Google."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Washa utashi wa skrini"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Skrini isizime wakati ninaiangalia"</string>
    <string name="power_consumption_footer_summary" msgid="4901490700555257237">"Muda mrefu wa skrini kujizima hutumia nishati zaidi ya betri."</string>
    <string name="auto_rotate_camera_lock_title" msgid="5369003176695105872">"Kamera imefungwa"</string>
    <string name="auto_rotate_camera_lock_summary" msgid="5699491516271544672">"Unahitaji kufungua Kamera ili utumie kipengele cha Utambuzi wa Nyuso"</string>
    <string name="adaptive_sleep_camera_lock_summary" msgid="8417541183603618098">"Unahitaji kufungua Kamera ili utumie kipengele cha Utashi wa Skrini"</string>
    <string name="auto_rotate_summary_no_permission" msgid="1025061139746254554">"Unahitaji ruhusa ya kufikia kamera ili utumie kipengele cha Utambuzi wa Nyuso. Gusa ili udhibiti ruhusa za Huduma za Kubadilisha Kifaa Upendavyo"</string>
    <string name="auto_rotate_manage_permission_button" msgid="2591146085906382385">"Dhibiti ruhusa"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Mwanga wa Usiku"</string>
    <string name="night_display_text" msgid="4789324042428095383">"Mwanga wa Usiku hugeuza rangi ya skrini yako kuwa manjano. Hali hii hufanya iwe rahisi kuangalia skrini yako au kusoma katika mwangaza hafifu na inaweza kukusaidia ulale kwa urahisi zaidi."</string>
    <string name="night_display_auto_mode_title" msgid="5869128421470824381">"Ratiba"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Hamna"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Washa wakati maalum"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Washa usiku kucha"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Kuanza"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Kuisha"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Ukolezaji"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Hautawahi kuwashwa kiotomatiki"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Itawashwa kiotomatiki saa <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Itawashwa kiotomatiki jua litakapotua"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Haitawahi kuzimwa kiotomatiki"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Itazimwa kiotomatiki saa <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Itazima kiotomatiki kutakapopambazuka"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Umezima Mwangaza wa Usiku"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Maelezo ya mahali kifaa kilipo yanahitajika ili kutambua saa zako za macheo na machweo."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Mipangilio ya mahali"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Washa sasa"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Zima sasa"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Washa hadi macheo"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Zima hadi machweo"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Hali Nyeusi"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Ratiba"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Hamna"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Washa usiku kucha"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Washa wakati maalum"</string>
    <string name="dark_ui_auto_mode_custom_bedtime" msgid="8465023741946439266">"Yanajiwasha wakati wa kulala"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Hali"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Hayatawahi kuwashwa kiotomatiki"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Itawashwa kiotomatiki jua litakapotua"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Itawaka kiotomatiki saa <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_off_auto_mode_custom_bedtime" msgid="7759826673214624622">"Itajiwasha kiotomatiki wakati wa kulala"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Haitawahi kuzimwa kiotomatiki"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Itazima kiotomatiki kutakapopambazuka"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Itazima kiotomatiki saa <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_custom_bedtime" msgid="1976993025762551246">"Itajizima kiotomatiki wakati wa kulala ukiisha"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"Mandhari meusi hutumia mandharinyuma meusi ili kuboresha muda wa matumizi ya betri kwenye baadhi ya skrini. Ratiba za Mandhari meusi hujiwasha hadi skrini ya simu yako inapozima."</string>
    <string name="dark_ui_bedtime_footer_summary" msgid="5576501833145170581">"Kwa sasa mandhari meusi yanafuata ratiba yako ya hali tuli"</string>
    <string name="dark_ui_bedtime_footer_action" msgid="1493095487994054339">"Mipangilio ya Hali tuli"</string>
    <string name="even_dimmer_display_title" msgid="8589063452814896327">"Mwangaza Kufifia Zaidi"</string>
    <string name="even_dimmer_display_summary" msgid="120301078873242172">"Ruhusu mwangaza wa kifaa hiki ufifie kuliko kawaida"</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Muda wa skrini kujizima"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"Baada ya <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> za kutokuwa na shughuli"</string>
    <string name="screen_timeout_summary_not_set" msgid="5107680774964178875">"Haijawekwa"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Mandhari"</string>
    <string name="style_and_wallpaper_settings_title" msgid="2232042809407308946">"Mandhari na mtindo"</string>
    <string name="wallpaper_dashboard_summary" msgid="2324472863981057118">"Skrini ya kwanza, skrini iliyofungwa"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Badilisha mandhari"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Weka mapendeleo ya skrini yako"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Chagua mandhari kutoka"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Weka mapendeleo kwenye simu yako"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Jaribu miundo, mandhari tofauti na zaidi"</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Taswira ya skrini"</string>
    <string name="keywords_screensaver" msgid="7249337959432229172">"taswira ya skrini"</string>
    <string name="screensaver_settings_when_to_dream_bedtime" msgid="3279310576803094771">"Haipatikani kwa sababu umewasha hali ya wakati umelala"</string>
    <string name="screensaver_settings_toggle_title" msgid="6194634226897244374">"Tumia taswira ya skrini"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Wakati imeunganishwa na kifaa kingine au inapochaji"</string>
    <string name="screensaver_settings_summary_dock_and_charging" msgid="8485905100159376156">"Ikiwa imepachikwa na inachaji"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Inapochaji"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Wakati imeunganishwa na kifaa kingine"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Isiwahi"</string>
    <string name="screensaver_settings_summary_on" msgid="4210827304351483645">"Imewashwa / <xliff:g id="SCREEN_SAVER">%1$s</xliff:g>"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Imezimwa"</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Ianze lini?"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Inua ili uondoe kifaa katika hali tuli"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Onyesho tulivu"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Wakati wa kuonyesha"</string>
    <string name="doze_title" msgid="1523090408230862316">"Washa skrini ili upokee arifa"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Skrini ikiwa nyeusi, huwa inawaka arifa zinapoingia"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Onyesha saa na maelezo kila wakati"</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Inatumia chaji nyingi"</string>
    <string name="force_bold_text" msgid="4620929631102086716">"Herufi nzito"</string>
    <string name="title_font_size" msgid="570613010306330622">"Ukubwa wa fonti"</string>
    <string name="short_summary_font_size" msgid="8444689613442419978">"Fanya maandishi yawe makubwa zaidi au madogo zaidi"</string>
    <string name="sim_lock_settings" msgid="7331982427303002613">"Mipangilio ya kufunga SIM"</string>
    <string name="sim_lock_settings_category" msgid="6475255139493877786">"Kufunga SIM"</string>
    <string name="sim_pin_toggle" msgid="6814489621760857328">"Funga SIM"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Badilisha PIN ya SIM"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"PIN ya SIM"</string>
    <string name="sim_enable_sim_lock" msgid="6486354334679225748">"Funga SIM"</string>
    <string name="sim_disable_sim_lock" msgid="6939439812841857306">"Fungua SIM"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"PIN ya zamani ya SIM"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"Nambari mpya ya PIN ya SIM"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Andika PIN mpya tena"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"PIN ya SIM"</string>
    <string name="sim_invalid_pin_hint" msgid="3376397829969578877">"Andika PIN yenye namba 4 hadi 8"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"PIN hazilingani"</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"Umefaulu kubadilisha PIN ya SIM"</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"Imeshindwa kuzima PIN."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"Imeshindwa kuwasha PIN."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"Sawa"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Ghairi"</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"Ungependa kutumia <xliff:g id="CARRIER">%1$s</xliff:g> kwa ajili ya data ya mtandao wa simu?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"Unatumia <xliff:g id="CARRIER2_0">%2$s</xliff:g> kwa ajili ya data ya mtandao wa simu. Ukibadilisha uweke <xliff:g id="CARRIER1">%1$s</xliff:g>, <xliff:g id="CARRIER2_1">%2$s</xliff:g> haitatumika tena kwa ajili ya data ya mtandao wa simu."</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"Tumia <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="8850185380445309835">"Ungependa kusasisha SIM unayopendelea?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"<xliff:g id="NEW_SIM">%1$s</xliff:g> ndiyo SIM pekee iliyo katika kifaa chako. Ungependa kutumia SIM hii kupata data ya mtandao wa simu, kupiga simu na kutuma SMS?"</string>
    <string name="enable_auto_data_switch_dialog_title" msgid="3563043560556718994">"Ungependa kuboresha ufikiaji wa data ya mtandao wa simu?"</string>
    <string name="enable_auto_data_switch_dialog_message" msgid="5777287241521946883">"Ruhusu kifaa chako kibadilishe na kutumia <xliff:g id="BACKUP_CARRIER">%1$s</xliff:g> kiotomatiki kwa ajili ya data ya mtandao wa simu inapopatikana kwa ubora."</string>
    <string name="auto_data_switch_dialog_managed_profile_warning" msgid="6839438290079866605">\n\n"Huenda simu, ujumbe na trafiki ya mtandao vikaonekana kwa shirika lako."</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"Nambari ya PIN ya SIM uliyoweka si sahihi. Sasa lazima uwasiliane na mtoa huduma wako ili ukufungulie kifaa chako."</string>
    <string name="wrong_pin_code" msgid="8124222991071607958">"{count,plural, =1{Nambari ya PIN ya SIM si sahihi, unaweza kujaribu mara # kabla ya kulazimika kuwasiliana na mtoa huduma wako ili afungue kifaa chako.}other{Nambari ya PIN ya SIM si sahihi, unaweza kujaribu mara #.}}"</string>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"Nambari ya PIN ya SIM si sahihi. Unaweza kujaribu mara moja kabla ya kuwasiliana na mtoa huduma wako ili afungue kifaa chako."</string>
    <string name="pin_failed" msgid="3726505565797352255">"Utendakazi wa PIN ya SIM umeshindwa!"</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Masasisho ya mfumo"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Toleo la Android"</string>
    <string name="security_patch" msgid="4071756145347865382">"Sasisho la usalama la Android"</string>
    <string name="model_info" msgid="8997566254717810904">"Muundo"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Toleo la maunzi"</string>
    <string name="manufactured_year" msgid="3401517138700926475">"Mwaka wa kutengenezwa"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"Kitambulisho cha Kifaa"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Toleo la Baseband"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Toleo la kiini"</string>
    <string name="build_number" msgid="9009733242117579826">"Nambari ya muundo"</string>
    <string name="module_version" msgid="1787518340082046658">"Sasisho la mfumo wa Google Play"</string>
    <string name="battery_info" msgid="7873528123969546728">"Maelezo kuhusu betri"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Haipatikani"</string>
    <string name="storage_settings" msgid="7472188817781592677">"Hifadhi"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Nafasi ya hifadhi na akiba"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Hifadhi mipangilio"</string>
    <string name="status_eid" msgid="7532406028683438634">"EID"</string>
    <string name="eid_multi_sim" msgid="9087924808336397804">"EID (sehemu ya sim <xliff:g id="EID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim" msgid="9001570420423929507">"IMEI (nafasi ya sim ya <xliff:g id="IMEI_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim_primary" msgid="7914653040843734282">"IMEI (nafasi ya sim <xliff:g id="IMEI_SLOT_ID_PRIMARY">%1$d</xliff:g>) (msingi)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Ili uangalie, chagua mtandao uliohifadhiwa"</string>
    <string name="status_imei" msgid="5719752369250485007">"IMEI"</string>
    <string name="status_imei_sv" msgid="6908985558726440951">"IMEI SV"</string>
    <string name="status_min_number" msgid="4492899165438225714">"NDOGO"</string>
    <string name="status_msid_number" msgid="3871958248824595774">"MSID"</string>
    <string name="status_prl_version" msgid="9002131357502714281">"Toleo la PRL"</string>
    <string name="meid_multi_sim" msgid="1460689549266621286">"MEID (nafasi ya sim <xliff:g id="MEID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="meid_multi_sim_primary" msgid="8921262417580407201">"MEID (nafasi ya sim <xliff:g id="MEID_SLOT_ID_PRIMARY">%1$d</xliff:g>) (msingi)"</string>
    <string name="scanning_status_text_on" msgid="3846571210578042940">"Imewashwa"</string>
    <string name="scanning_status_text_off" msgid="4002352668313705132">"Imezimwa"</string>
    <string name="status_meid_number" msgid="6040380838489162650">"MEID"</string>
    <string name="status_icc_id" msgid="7995690631650006970">"ICCID"</string>
    <string name="status_data_network_type" msgid="3689772955330665876">"Aina ya data ya mtandao wa simu"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Aina ya mtandao wa simu ya sauti"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Maelezo ya mtoa huduma"</string>
    <string name="status_data_state" msgid="525196229491743487">"Hali ya mtandao wa simu ya mkononi"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Hali ya huduma"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Nguvu za mawimbi"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Matumizi ya mitandao ya ng\'ambo"</string>
    <string name="status_operator" msgid="4335640583552058491">"Mtandao"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"Anwani ya MAC ya Wi-Fi"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"Anwani ya MAC ya Wi-Fi ya kifaa"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"Anwani ya Bluetooth"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Nambari ya Ufuatiliaji"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Muda wa kutumika tangu ilipowashwa"</string>
    <string name="battery_manufacture_date" msgid="7139426520156833987">"Tarehe ilipoundwa"</string>
    <string name="battery_first_use_date" msgid="3157207331722711317">"Tarehe ulipotumia mara ya kwanza"</string>
    <string name="battery_cycle_count" msgid="2912949283386571900">"Mara ambazo betri imejaa"</string>
    <string name="battery_cycle_count_not_available" msgid="2426584515665184664">"Haipatikani"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Inahesabu..."</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Badilisha jina"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Pachika"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Ondoa"</string>
    <string name="storage_menu_format" msgid="8903698999905354146">"Andaa kadi ya SD kwa ajili ya hifadhi inayohamishika"</string>
    <string name="storage_menu_format_button" msgid="7623565190643699626">"Andaa kadi"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Weka muundo uwe inahamishika"</string>
    <string name="storage_menu_format_option" msgid="4886059624052908432">"Andaa diski"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Hamisha data"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Sahau"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Weka mipangilio"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Futa baadhi ya yaliyomo"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Dhibiti hifadhi"</string>
    <string name="storage_free_up_space_title" msgid="281047807372131975">"Futa ili upate nafasi"</string>
    <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Nenda kwenye programu ya Files ili udhibiti na kufuta faili upate nafasi zaidi"</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Watumiaji wengine"</string>
    <string name="storage_size_large" msgid="1155308277890194878">"<xliff:g id="NUMBER">^1</xliff:g>"<small><small>" <xliff:g id="UNIT">^2</xliff:g>"</small></small>""</string>
    <string name="storage_mount_success" msgid="393972242641313135">"<xliff:g id="NAME">%1$s</xliff:g> imepachikwa"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"Haikuweza kupachika <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"<xliff:g id="NAME">%1$s</xliff:g> imeondolewa kwa usalama"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"Haikuweza kuondoa <xliff:g id="NAME">%1$s</xliff:g> kwa usalama"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Badilisha jina la hifadhi"</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"<xliff:g id="NAME_0">^1</xliff:g> hii imeharibika. \n\n Ili uweze kutumia <xliff:g id="NAME_1">^1</xliff:g> hii, ni lazima uweke mipangilio yake kwanza."</string>
    <string name="storage_internal_format_details" msgid="2399034372813686846">"Unaweza kuandaa kadi hii ya SD ili uweze kuhifadhi picha, video, muziki na zaidi, na uvifikie katika vifaa vingine. \n\n"<b>"Data yote kwenye kadi hii ya SD itafutwa."</b>" \n\n"<b>"Kabla ya kuandaa diski"</b>" \n\n"<b>"Hifadhi nakala za picha na maudhui mengine"</b>" \nHamishia faili zako za maudhui kwenye nafasi mbadala ya hifadhi katika kifaa hiki au zihamishie kwenye kompyuta yako kwa kutumia Kebo ya USB. \n\n"<b>"Hifadhi nakala za programu"</b>" \nProgramu zote zilizohifadhiwa kwenye <xliff:g id="NAME">^1</xliff:g> zitaondolewa na data itafutwa. Ili uhifadhi programu hizi, zihamishie kwenye nafasi mbadala ya hifadhi katika kifaa hiki."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><b>"Unapoondoa <xliff:g id="NAME_0">^1</xliff:g> hii, programu zilizohifadhiwa ndani yake zitaacha kufanya kazi, na faili za maudhui zilizohifadhiwa ndani yake hazitapatikana hadi itakapoingizwa tena.<xliff:g id="NAME_1">^1</xliff:g>\n\n"</b>"hii imepangiliwa ili ifanye kazi kwenye kifaa hiki pekee. Haitafanya kazi kwenye vifaa vingine vyovyote."</string>
    <string name="storage_internal_forget_details" msgid="5606507270046186691">"Ili utumie programu, picha na data zilizo kwenye <xliff:g id="NAME">^1</xliff:g> hii, iingize tena. \n\nAma, unaweza kuamua kusahau hifadhi hii ikiwa kifaa hakipatikani. \n\nUkiamua kusahau, data yote iliyo kwenye kifaa itapotea kabisa. \n\nUnaweza kusakinisha upya programu baadaye, lakini data iliyohifadhiwa kwenye kifaa hiki itapotea."</string>
    <string name="storage_internal_forget_confirm_title" msgid="379238668153099015">"Ungetaka kusahau <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"Programu, picha, na data zote zilizohifadhiwa kwenye <xliff:g id="NAME">^1</xliff:g> hii zitapotea kabisa."</string>
    <string name="storage_detail_dialog_system" msgid="7461009051858709479">"Mfumo unajumuisha faili zinazotumika katika toleo la Android la <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="storage_wizard_guest" msgid="5813419895687733649">"Watumiaji wageni hawawezi kuandaa diski za kadi za SD"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"Inapanga <xliff:g id="NAME">^1</xliff:g>..."</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Usiondoe <xliff:g id="NAME">^1</xliff:g> inapoumbizwa."</string>
    <string name="storage_wizard_ready_title" msgid="3631022511474086605">"Umeandaa diski ya <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"Hamisha <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"Kuhamisha <xliff:g id="APP">^1</xliff:g> na data yake kwenda <xliff:g id="NAME_0">^2</xliff:g> kutachukua dakika chache tu. Hutaweza kutumia programu hadi ukamilishe kuhamisha. \n\nUsiondoe <xliff:g id="NAME_1">^2</xliff:g> wakati wa kuhamisha."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"Ili kuhamisha data, unahitaji kufungua <xliff:g id="APP">^1</xliff:g> ya mtumiaji."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"Inahamisha <xliff:g id="APP">^1</xliff:g>..."</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"Usionde <xliff:g id="NAME">^1</xliff:g> wakati wa kuhamisha. \n\nProgramu ya <xliff:g id="APP">^2</xliff:g> haitapatikana kwenye kifaa hiki hadi ukamilishe kuhamisha."</string>
    <string name="storage_wizard_init_v2_title" msgid="2538630338392381113">"Ungependa kutumia <xliff:g id="NAME">^1</xliff:g> hii vipi?"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"Au"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="2786416384217054112">"Andaa kadi ya SD kwa ajili ya hifadhi inayohamishika"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="2002761631147966185">"Hifadhi picha, video, muziki na zaidi, na uvifikie katika vifaa vingine. &lt;a href=https://support.google.com/android/answer/12153449&gt;Pata maelezo zaidi kuhusu kuweka mipangilio ya kadi ya SD&lt;/a&gt;."</string>
    <string name="storage_wizard_init_v2_external_action" msgid="6140058734875839081">"Andaa diski"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Weka mipangilio baadaye"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"Ungependa kuandaa <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"Unahitaji kuandaa <xliff:g id="NAME_0">^1</xliff:g> ili uhifadhi programu, faili na maudhui. \n\nHatua ya kuandaa itafuta maudhui yote yaliyo katika <xliff:g id="NAME_1">^2</xliff:g>. Ili usipoteze maudhui, hifadhi nakala kwenye <xliff:g id="NAME_2">^3</xliff:g> au kifaa kingine."</string>
    <string name="storage_wizard_format_confirm_v2_body_external" msgid="5810296966099830035">"Unahitaji kuandaa <xliff:g id="NAME_0">^1</xliff:g> ili uhifadhi picha, video, muziki na zaidi. \n\nKuandaa diski kutafuta maudhui yote yaliyopo kwenye <xliff:g id="NAME_1">^2</xliff:g>. Ili usipoteze maudhui, hifadhi nakala hizo za data kwenye <xliff:g id="NAME_2">^3</xliff:g> au kifaa kingine."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"Rekebisha muundo: <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Utahamishia maudhu kwenye <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"Wakati inahamisha:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"Usiondoe <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Baadhi ya programu hazitafanya kazi"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Hamisha maudhui"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Hamisha maudhui baadaye"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Inahamisha maudhui…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"<xliff:g id="NAME">^1</xliff:g> inafanya kazi polepole"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"Bado unaweza kutumia <xliff:g id="NAME_0">^1</xliff:g> hii, lakini huenda ikachukua muda mrefu. \n\nHuenda programu ambazo zimehifadhiwa kwenye <xliff:g id="NAME_1">^2</xliff:g> hii zisifanye kazi vizuri, na uhamishaji wa maudhui unaweza kuchukua muda mrefu. \n\nJaribu kutumia <xliff:g id="NAME_2">^3</xliff:g> inayofanya kazi haraka, au utumie <xliff:g id="NAME_3">^4</xliff:g> hii kwa ajili ya hifadhi inayohamishika badala yake."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Anza tena"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Endelea"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="7688457485389886923">"Unaweza kuanza kutumia <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="3520269956641115883">"Unaweza kuanza kutumia <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1163588718127651062">"Unaweza kuanza kutumia <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="battery_status_title" msgid="4661768220545945771">"Hali ya betri"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Kiwango cha betri"</string>
    <string name="communal_settings_title" msgid="2845678473945902115">"Ya jumuiya"</string>
    <string name="communal_settings_summary" msgid="4923914136953940317">"Mipangilio ya jumuiya"</string>
    <string name="satellite_setting" msgid="706846910912477125">"Kutuma Ujumbe Kupitia Setilaiti"</string>
    <string name="apn_settings" msgid="4295467389400441299">"APN"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Badilisha mahali pa kufikia"</string>
    <string name="apn_add" msgid="9069613192201630934">"Weka mlango wa mtandao"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"Haijawekwa"</string>
    <string name="apn_not_set_for_mvno" msgid="1141490067313964640">"Haijawekwa"</string>
    <string name="apn_name" msgid="6677695784108157953">"Jina"</string>
    <string name="apn_apn" msgid="5812828833797458602">"APN"</string>
    <string name="apn_http_proxy" msgid="1052464912365838007">"Seva mbadala"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Mlango"</string>
    <string name="apn_user" msgid="5831763936428279228">"Jina la mtumiaji"</string>
    <string name="apn_password" msgid="7435086635953953029">"Nenosiri"</string>
    <string name="apn_server" msgid="6997704279138388384">"Seva"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"Proksi ya MMS"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"Mlango wa  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">"Aina ya uthibitishaji"</string>
    <string name="apn_type" msgid="1835573305077788773">"Aina ya APN"</string>
    <string name="apn_protocol" msgid="181529867160380010">"Itifaki ya APN"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"Itifaki ya APN: mitandao ya ng\'ambo"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"APN washa/zima"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"APN imewashwa"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"APN imezimwa"</string>
    <string name="bearer" msgid="3231443241639159358">"Mwenye"</string>
    <string name="network_type" msgid="748590707422733595">"Aina ya mtandao"</string>
    <string name="network_type_unspecified" msgid="7756349656194518725">"Haijabainishwa"</string>
    <string name="mvno_type" msgid="4734654257494971247">"Aina ya MVNO"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"Thamani ya MVNO"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Futa APN"</string>
    <string name="menu_new" msgid="6571230342655509006">"APN Mpya"</string>
    <string name="menu_save" msgid="6611465355127483100">"Hifadhi"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Ghairi"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_duplicate_apn_entry" msgid="7792928408935276618">"Nakala ya data ya apn."</string>
    <string name="error_name_empty" msgid="1258275899283079142">"Huwezi kuacha sehemu hii ikiwa haijajazwa."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"Lazima APN ijazwe."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"Sehemu ya MCC lazima iwe na namba 3."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"Sehemu ya MNC lazima iwe na namba 2 au 3."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"Mtoa huduma haruhusu kuongeza APN za aina ya %s."</string>
    <string name="error_mmsc_valid" msgid="8380951905485647380">"Ni lazima sehemu ya MMSC iwe sahihi."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Inarejesha mipangilio mbadala ya APN"</string>
    <string name="menu_restore" msgid="4310539620115151551">"Rudisha kwenye chaguomsingi"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Kuweka upya kwa mipangilio mbadala ya APN kumekamilika"</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Chaguo za kubadili"</string>
    <string name="reset_mobile_network_settings_title" msgid="5616713931258506842">"Weka upya Mipangilio ya Mtandao wa Simu"</string>
    <string name="reset_mobile_network_settings_desc" msgid="7292636387692165727">"Hali hii itaweka upya mipangilio yote ya mtandao wa simu"</string>
    <string name="reset_mobile_network_settings_confirm_title" msgid="7510965634669511241">"Ungependa kuweka upya Mipangilio ya Mtandao wa Simu?"</string>
    <string name="reset_bluetooth_wifi_title" msgid="4113071322344697317">"Weka upya Bluetooth na Wi‑Fi"</string>
    <string name="reset_bluetooth_wifi_desc" msgid="4030295669083059711">"Hali hii itaweka upya mipangilio ya Wi-Fi na Bluetooth. Huwezi kutendua kitendo hiki."</string>
    <string name="reset_bluetooth_wifi_button_text" msgid="3974098137045963639">"Weka upya"</string>
    <string name="reset_bluetooth_wifi_complete_toast" msgid="5893439291030574365">"Bluetooth na Wi‑Fi vimewekwa upya"</string>
    <string name="reset_esim_title" msgid="4194570573425902754">"Futa eSIM"</string>
    <string name="reset_esim_desc" msgid="6125192435907740751">"Hatua hii haitakata mpango wako wa huduma ya simu. Ili upate SIM nyingine, wasiliana na mtoa huduma wako."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Badilisha mipangilio"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Je, ungependa kubadilisha mipangilio yote ya mtandao? Huwezi kutendua kitendo hiki."</string>
    <string name="reset_network_final_desc_esim" msgid="1129251284212847939">"Ungependa kuweka upya mipangilio ya mtandao na kufuta eSIM? Huwezi kutendua kitendo hiki."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Badilisha mipangilio"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Iwekwe upya?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"Kuweka upya mtandao hakupatikani kwa mtumiaji huyu"</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Mipangilio ya mtandao imewekwa upya"</string>
    <string name="reset_esim_error_title" msgid="6516110227665862295">"Imeshindwa kufuta eSIM"</string>
    <string name="reset_esim_error_msg" msgid="8459527827897797168">"Hitilafu fulani imetokea na eSIM zako hazijafutwa.\n\nZima kisha uwashe kifaa chako na ujaribu tena."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Futa data yote (rejesha mipangilio iliyotoka nayo kiwandani)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Futa data yote (rejesha mipangilio Iliyotoka nayo kiwandani)"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"Muziki"</li>\n<li>"Picha"</li>\n<li>"data nyingine ya mtumiaji"</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729"><li>"eSIM"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"Hatua hii haitaghairi mpango wako wa huduma ya simu ya mkononi."</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Taarifa binafsi na programu zako zote zilizopakuliwa zitafutwa. Huwezi kutendua kitendo hiki."</string>
    <string name="main_clear_final_desc_esim" msgid="6592404057237813989">"Taarifa zako zote binafsi, ikiwa ni pamoja na programu ulizopakua na SIM, zitafutwa. Huwezi kutendua kitendo hiki."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"Ungependa kufuta data yote?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"Urejeshaji wa mipangilio ya kiwandani haupatikani kwa mtumiaji huyu"</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Inafuta"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Tafadhali subiri…"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Mipangilio ya simu"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Weka mipangilio ya ujumbe wa sauti, kupitisha simu, kusubiri simu, kitambulisho cha mteja"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"Sambaza mtandao kwa USB"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Intaneti ya kusambazwa"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Sambaza mtandao kwa Bluetooth"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Kusambaza mtandao"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Mtandaopepe na usambazaji wa mtandao"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Mtandaopepe umewashwa, inasambaza mtandao"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Mtandaopepe umewashwa"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Inasambaza mtandao"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"Haiwezi kusambaza mtandao au kutumia mitandaopepe wakati umewasha Kiokoa Data"</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Mtandaopepe pekee"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"USB pekee"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Bluetooth pekee"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Ethaneti pekee"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Mtandaopepe, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Mtandaopepe, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Mtandao pepe, Ethaneti"</string>
    <string name="tether_settings_summary_usb_and_bluetooth" msgid="1355680331767261967">"USB, Bluetooth"</string>
    <string name="tether_settings_summary_usb_and_ethernet" msgid="2195017679820919905">"USB, Ethaneti"</string>
    <string name="tether_settings_summary_bluetooth_and_ethernet" msgid="1015253926959211012">"Bluetooth, Ethaneti"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_bluetooth" msgid="2949043525073791732">"Mtandaopepe, USB, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Mtandao pepe, USB, Ethaneti"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Mtandao pepe, Bluetooth, Ethaneti"</string>
    <string name="tether_settings_summary_usb_and_bluetooth_and_ethernet" msgid="5880591133984166550">"USB, Bluetooth, Ethaneti"</string>
    <string name="tether_settings_summary_all" msgid="7565193614882005775">"Mtandao pepe, USB, Bluetooth, Ethaneti"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Haishiriki intaneti na vifaa vingine"</string>
    <string name="tether_preference_summary_off" msgid="6266799346319794630">"Imezimwa"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"Sambaza mtandao kwa USB"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Sambaza mtandao kwa Bluetooth"</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Sambaza mtandao kwa Ethaneti"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Tumia mtandao pepe na kipengele cha kusambaza mtandao ili ushiriki intaneti na vifaa vingine kupitia muunganisho wa data wa simu za mkononi. Programu pia zinaweza kuunda mtandao pepe ili kushiriki maudhui na vifaa vilivyo karibu."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Tumia mtandaopepe na huduma ya kusambaza mtandao ili uvisambazie vifaa vingine intaneti kupitia muunganisho wa data wa simu au Wi-Fi. Programu pia zinaweza kuunda mtandaopepe ili kushiriki maudhui na vifaa vilivyo karibu."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Usaidizi"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Mtandao wa simu"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"Programu ya SMS"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Ungependa kubadilisha programu ya SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"Ungependa kutumia <xliff:g id="NEW_APP">%1$s</xliff:g> badala ya <xliff:g id="CURRENT_APP">%2$s</xliff:g> kama programu yako ya SMS?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="6215622785087181275">"Ungependa kutumia <xliff:g id="NEW_APP">%s</xliff:g> kama programu yako ya SMS?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"Ungependa kubadili kisaidizi cha Wi-Fi?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"Ungependa kutumia <xliff:g id="NEW_APP">%1$s</xliff:g> badala ya <xliff:g id="CURRENT_APP">%2$s</xliff:g> kusimamia miunganisho yako ya mtandao?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Ungependa kutumia <xliff:g id="NEW_APP">%s</xliff:g> kusimamia miunganisho yako ya mtandao?"</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Maombi ya hivi karibuni ya kutambua mahali"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Wasifu wa kazi kutambua mahali"</string>
    <string name="location_app_level_permissions" msgid="907206607664629759">"Ruhusa za programu kufikia mahali"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Utambuzi wa mahali umezimwa"</string>
    <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{Programu # kati ya {total} ina idhini ya kufikia data ya mahali}other{Programu # kati ya {total} zina idhini ya kufikia data ya mahali}}"</string>
    <string name="location_category_recent_location_access" msgid="2558063524482178146">"Ufikiaji wa hivi karibuni"</string>
    <string name="location_recent_location_access_see_all" msgid="4203102419355323325">"Angalia zote"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Angalia maelezo"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"Hakuna programu iliyotaka kutambua mahali hivi karibuni"</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Hakuna programu iliyofikia mahali hivi karibuni"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Matumizi ya betri ya hali ya juu"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Huwa haitumii chaji nyingi"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"Kutafuta Wi-Fi"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Ruhusu programu na huduma zitafute mitandao ya Wi-Fi wakati wowote, hata wakati umezima Wi-Fi. Hali hii inaweza kutumika, kwa mfano, kuboresha huduma na vipengele vinavyohusiana na mahali."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Kutafuta Bluetooth"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Ruhusu programu na huduma zitafute vifaa vilivyo karibu wakati wowote, hata wakati umezima Bluetooth. Hali hii inaweza kutumika, kwa mfano, kuboresha huduma na vipengele vinavyohusiana na mahali."</string>
    <string name="location_services_preference_title" msgid="604317859531782159">"Huduma za mahali"</string>
    <string name="location_services_screen_title" msgid="5640002489976602476">"Huduma za mahali"</string>
    <string name="location_time_zone_detection_toggle_title" msgid="6478751613645015287">"Tumia data ya mahali"</string>
    <string name="location_time_zone_detection_status_title" msgid="8903495354385600423">"Huwezi kuweka saa za eneo kiotomatiki"</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">"Data ya mahali au Huduma za Mahali zimezimwa"</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">"Maelezo ya mahali kilipo kifaa yanahitajika"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_message" msgid="5846316326139169523">"Ili uweke saa za eneo ukitumia eneo uliko, washa mipangilio ya mahali, kisha usasishe mipangilio ya saa za eneo"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_ok_button" msgid="2685647335717750297">"Mipangilio ya mahali"</string>
    <string name="location_time_zone_provider_fix_dialog_ok_button" msgid="9026666001835079126">"Rekebisha hii"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_cancel_button" msgid="3968729678789071154">"Ghairi"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="6264253990141650280">"Utambuzi otomatiki wa saa za eneo umezimwa"</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"Utambuzi wa saa za eneo umezimwa"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"Utambuzi wa saa za eneo hautumiki"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Huruhusiwi kufanya mabadiliko kwenye utambuzi wa saa za eneo"</string>
    <string name="location_time_zone_detection_auto_is_on" msgid="8797434659844659323">"Huenda data ya mahali ikatumika kuweka saa za eneo"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Angalia maelezo ya kisheria, hadhi, toleo la programu"</string>
    <string name="legal_information" msgid="7509900979811934843">"Maelezo ya kisheria"</string>
    <string name="manual" msgid="3651593989906084868">"Mwongozo"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Lebo za udhibiti"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Mwongozo wa usalama na udhibiti"</string>
    <string name="copyright_title" msgid="83245306827757857">"Hakimiliki"</string>
    <string name="license_title" msgid="8745742085916617540">"Leseni"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Leseni za sasisho la mfumo wa Google Play"</string>
    <string name="terms_title" msgid="2071742973672326073">"Sheria na Masharti"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"Leseni ya WebView ya Mfumo"</string>
    <string name="wallpaper_attributions" msgid="4323659759250650736">"Waliohusika na mandhari"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Watoa huduma wa picha za setilaiti: \n©2014 CNES / Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Mwongozo"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Kumekuwa na hitilafu katika kupakia mwongozo."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Leseni za watu au kampuni nyingine"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Kuna hitilafu wakati wa kupakia leseni"</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Inapakia…"</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Inapakia…"</string>
    <string name="lockpassword_choose_your_password_header" msgid="2407205113298094824">"Weka nenosiri"</string>
    <string name="lockpassword_choose_your_profile_password_header" msgid="7038997227611893312">"Weka nenosiri la wasifu wa kazini"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7754265746504679473">"Weka PIN"</string>
    <string name="lockpassword_choose_your_profile_pin_header" msgid="4581749963670819048">"Weka PIN ya wasifu wa kazini"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="5674909390779586252">"Weka mchoro"</string>
    <string name="lockpassword_choose_your_pattern_description" msgid="6808109256008481046">"Ili kuimarisha usalama, weka mchoro wa kufungua kifaa"</string>
    <string name="lockpassword_choose_your_profile_pattern_header" msgid="3101811498330756641">"Weka mchoro wa wasifu wa kazini"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Weka nenosiri ili utumie alama ya kidole"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Weka mchoro ili utumie alama ya kidole"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Kwa sababu za usalama, weka PIN"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Weka PIN ili utumie alama ya kidole"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Weka nenosiri lako tena"</string>
    <string name="lockpassword_reenter_your_profile_password_header" msgid="3812040127714827685">"Weka nenosiri lako la kazini tena"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Weka nenosiri lako la kazini"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Thibitisha mchoro wako"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Weka mchoro wako wa kazini"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Weka PIN yako tena"</string>
    <string name="lockpassword_reenter_your_profile_pin_header" msgid="2890233614560435538">"Weka PIN yako ya kazini tena"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Weka PIN yako ya kazini"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Nenosiri halilingani"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"PIN hailingani"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Chora mchoro wako tena"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Chaguo zilizomo"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Nenosiri limewekwa"</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"PIN imewekwa"</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Mchoro umewekwa"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="622276003801157839">"Ili utumie kipengele cha Kufungua kwa uso, weka nenosiri"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="7333603579958317102">"Ili utumie kipengele cha Kufungua kwa uso, weka mchoro"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="704061826984851309">"Ili utumie kipengele cha Kufungua kwa uso, weka PIN"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="2053366309272487015">"Weka nenosiri ili utumie uso au alama ya kidole"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4038476475293734905">"Weka mchoro ili utumie uso au alama ya kidole"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="9086039918921009380">"Weka PIN ili utumie uso au alama ya kidole"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Je, umesahau nenosiri lako?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Je, umesahau mchoro wako?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"Je, umesahau PIN yako?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7401165571170203743">"Chora mchoro wako ili uendelee"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="8990266101852808091">"Weka PIN yako ili uendelee"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="8823867445451497224">"Weka nenosiri lako ili uendelee"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="7003851856761939690">"Chora mchoro wa wasifu wako wa kazini ili uendelee"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Weka PIN ya kazini ili uendelee"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Weka nenosiri lako ili uendelee"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Ili kuimarisha usalama, tumia mchoro wa kufungua kifaa chako"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Ili kuimarisha usalama, weka PIN ya kifaa chako"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Ili kuimarisha usalama, weka nenosiri la kifaa chako"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Ili kuimarisha usalama, weka mchoro wa wasifu wako wa kazini"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Ili kuimarisha usalama, weka PIN ya wasifu wako wa kazini"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Ili kuimarisha usalama, weka nenosiri la wasifu wako wa kazini"</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Thibitisha mchoro"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"Thibitisha PIN"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Thibitisha nenosiri"</string>
    <string name="lockpassword_remote_validation_header" msgid="4992647285784962073">"Thibitisha kwamba ni wewe"</string>
    <string name="lockpassword_remote_validation_pattern_details" msgid="4655537780358707983">"Ili uhamishe Akaunti za Google, mipangilio na zaidi, weka mchoro wa kifaa chako kingine. Mchoro wako umesimbwa kwa njia fiche."</string>
    <string name="lockpassword_remote_validation_pin_details" msgid="2373654227583206297">"Ili uhamishe Akaunti za Google, mipangilio na zaidi, weka PIN ya kifaa chako kingine. PIN yako imesimbwa kwa njia fiche."</string>
    <string name="lockpassword_remote_validation_password_details" msgid="3482328925925888340">"Ili uhamishe Akaunti za Google, mipangilio na zaidi, weka nenosiri la kifaa chako kingine. Nenosiri lako limesimbwa kwa njia fiche."</string>
    <string name="lockpassword_remote_validation_set_pattern_as_screenlock" msgid="7595104317648465901">"Pia, tumia mchoro ili ufungue kifaa hiki"</string>
    <string name="lockpassword_remote_validation_set_pin_as_screenlock" msgid="509672303005547218">"Pia, tumia PIN ufungue kifaa hiki"</string>
    <string name="lockpassword_remote_validation_set_password_as_screenlock" msgid="2066701840753591922">"Pia, tumia nenosiri ili ufungue kifaa hiki"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_header" msgid="6669435143987988314">"Thibitisha mchoro"</string>
    <string name="lockpassword_confirm_repair_mode_pin_header" msgid="2585263648322879131">"Thibitisha PIN"</string>
    <string name="lockpassword_confirm_repair_mode_password_header" msgid="3064676176428495228">"Thibitisha nenosiri"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_details" msgid="6187536224419477465">"Weka mchoro wa kufungua kifaa chako ili uendelee"</string>
    <string name="lockpassword_confirm_repair_mode_pin_details" msgid="203022189107305807">"Weka PIN ya kifaa chako ili uendelee"</string>
    <string name="lockpassword_confirm_repair_mode_password_details" msgid="4860219600771003873">"Weka nenosiri la kifaa chako ili uendelee"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"Nambari ya PIN si sahihi"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Nenosiri si sahihi"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Mchoro huo si sahihi"</string>
    <string name="work_challenge_emergency_button_text" msgid="5529942788380505927">"Simu za dharura"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Usalama wa kifaa"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Badilisha umbo la kufungua"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Badilisha PIN ya kufungua"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Mchoro wa kufungua"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Bonyeza menyu upate usaidizi"</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Ondoa kidole ukimaliza"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Unganisha angalau vitone <xliff:g id="NUMBER">%d</xliff:g>. Jaribu tena."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Mchoro wa kufungua umerekodiwa"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Uchore tena ili kuthibitisha"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Mchoro wako mpya wa kufungua"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Thibitisha"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Chora tena"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Futa"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Endelea"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Mchoro wa kufungua"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Inahitaji mchoro"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Lazima uchore umbo kufungua skrini"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Fanya mchoro uonekane"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_title" msgid="7172693275721931683">"Faragha ya PIN iliyoboreshwa"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_summary" msgid="8639588868341114740">"Zima uhuishaji unapoweka PIN"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Fanya mchoro wa skrini uonekane"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Toa mtetemo ikigongwa"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Funga skrini kwa kitufe cha nishati"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"Isipokuwa kinapowekwa bila kufungwa na <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="2193588309557281466">"Weka mchoro wa kufungua"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Badilisha umbo la kufungua"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Jinsi ya kuchora mchoro wa kufungua"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Majaribio mengi mno yasiyo sahihi. Jaribu tena baada ya sekunde <xliff:g id="NUMBER">%d</xliff:g>."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"Programu haijasakinishwa kwenye simu yako."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Usalama wa wasifu wa kazini"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Kufunga skrini ya wasifu wa kazini"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Tumia mbinu moja ya kufunga"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Tumia mbinu moja ya kufunga wasifu wa kazini na skrini ya kifaa"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"Ungependa kutumia mbinu moja ya kufunga?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"Kifaa chako kitatumia mbinu ya kufunga skrini ya wasifu wako wa kazini. Sera za kazini zitatumika katika kufunga skrini"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"Mbinu yako ya kufunga wasifu wa kazini haitimizi masharti ya usalama wa shirika lako. Unaweza kutumia mbinu sawa kwenye skrini ya kifaa chako na wasifu wako wa kazini, lakini sera zozote za kufunga skrini ya kazini zitatumika."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Tumia mbinu moja ya kufunga"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Tumia mbinu moja ya kufunga"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Sawa na njia ya kufunga skrini ya kifaa"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Dhibiti programu"</string>
    <string name="applications_settings" msgid="1941993743933425622">"Maelezo ya programu"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"Mipangilio ya programu"</string>
    <string name="install_applications" msgid="3921609656584369901">"Vyanzo visivyojulikana"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Ruhusu vyanzo vyote vya programu"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Programu ulizofungua hivi karibuni"</string>
    <string name="see_all_apps_title" msgid="1650653853942381797">"{count,plural, =1{Angalia programu zote}other{Angalia programu zote #}}"</string>
    <string name="forgot_password_title" msgid="3967873480875239885">"Wasiliana na msimamizi wako wa TEHAMA"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"Anaweza kukusaidia kubadilisha PIN, mchoro au nenosiri lako"</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Mipangilio ya kina"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Wezesha chaguo zaidi ya mipangilio."</string>
    <string name="application_info_label" msgid="1015706497694165866">"Maelezo ya programu"</string>
    <string name="storage_label" msgid="2522307545547515733">"Hifadhi"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Fungua moja kwa moja"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Chaguomsingi"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Utangamanifu wa skrini"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Ruhusa"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Akiba"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Futa data iliyoakibishwa"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Akiba"</string>
    <string name="uri_permissions_text" msgid="8406345863117405105">"{count,plural, =1{Kipengee 1}other{Vipengee #}}"</string>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Futa ufikiaji"</string>
    <string name="controls_label" msgid="8671492254263626383">"Vidhibiti"</string>
    <string name="force_stop" msgid="2681771622136916280">"Lazimisha kuzima"</string>
    <string name="archive" msgid="9074663845068632127">"Hifadhi kwenye kumbukumbu"</string>
    <string name="restore" msgid="7622486640713967157">"Rejesha"</string>
    <string name="restoring_step_one" msgid="3465050101254272874">"Inarejesha"</string>
    <string name="restoring_step_two" msgid="140484846432595108">"Inarejesha."</string>
    <string name="restoring_step_three" msgid="3712883580876329811">"Inarejesha.."</string>
    <string name="restoring_step_four" msgid="8966846882470446209">"Inarejesha..."</string>
    <string name="total_size_label" msgid="2052185048749658866">"Jumla"</string>
    <string name="application_size_label" msgid="6407051020651716729">"Ukubwa wa programu"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"Programu ya hifadhi ya USB"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Data ya mtumiaji"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Ondoa"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Ondolea watumiaji wote"</string>
    <string name="install_text" msgid="4558333621516996473">"Weka"</string>
    <string name="disable_text" msgid="5146002260857428005">"Zima"</string>
    <string name="enable_text" msgid="8570798764647110430">"Washa"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Futa data ya hifadhi"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Ondoa masasisho"</string>
    <string name="app_restricted_settings_lockscreen_title" msgid="5993061278264872648">"Ruhusu mipangilio iliyozuiliwa"</string>
    <string name="auto_launch_enable_text" msgid="8912714475823807798">"Baadhi ya shughuli ulizochagua hufunguka katika programu hii kwa chaguomsingi."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Umechagua kuruhusu programu hii kuunda wijeti na kufikia data yao."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"Hakuna chaguo-misingi zilizowekwa."</string>
    <string name="clear_activities" msgid="488089228657585700">"Ondoa mapendeleo chaguomsingi"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"Programu hii haiwezi kuundwa kwa skrini yako: Unaweza kudhibiti jinsi inavyojirekebidhwa kwa skrini yako hapa."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Uliza wakati imezinduliwa"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Pima programu"</string>
    <string name="unknown" msgid="8192160131923461175">"Haijulikani"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Panga kwa jina"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Panga kwa ukubwa"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Iliyotuma karibuni zaidi"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Inayotuma arifa zaidi"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Onyesha huduma zinazoendeshwa"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Onyesha michakato iliyoakibishwa"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Programu ya dharura"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Badilisha mapendeleo ya programu"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"Ungependa kubadilisha mapendeleo ya programu?"</string>
    <string name="reset_app_preferences_desc" msgid="8550782670650158299">"Hatua hii itaweka upya mapendeleo yote ya:\n\n"<li>"Programu zilizozimwa"</li>\n<li>"Arifa za programu zilizozimwa"</li>\n<li>"Programu chaguomsingi za vitendo"</li>\n<li>"Udhibiti wa data ya chinichini katika programu"</li>\n<li>"Udhibiti wowote wa ruhusa"</li>\n<li>"Mipangilio ya Matumizi ya betri"</li>\n\n"Hutapoteza data yoyote ya programu."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Weka upya"</string>
    <string name="filter" msgid="9039576690686251462">"Kichujio"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Chagua chaguzi za vichujio"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Programu zote"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Programu zilizozimwa"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Zilizopakuliwa"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Zinazotumika"</string>
    <string name="not_installed" msgid="5074606858798519449">"Haijasanidiwa kwa mtumiaji huyu"</string>
    <string name="installed" msgid="2837449358488825884">"Imesakinishwa"</string>
    <string name="no_applications" msgid="985069304755391640">"Hakuna programu yoyote."</string>
    <string name="internal_storage" msgid="999496851424448809">"Hifadhi ya ndani"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Kiwango cha kukadiria upya"</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Ungependa kufuta data ya programu?"</string>
    <string name="clear_data_dlg_text" msgid="3440011276559762619">"Data ya programu, ikiwemo faili na mipangilio, zitafutwa kabisa kwenye kifaa hiki"</string>
    <string name="dlg_ok" msgid="1421350367857960997">"Sawa"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Ghairi"</string>
    <string name="dlg_delete" msgid="1790919205039397659">"Futa"</string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"Programu haikupatikana katika orodha ya programu za kompyuta zilizosakinishwa."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Imeshindwa kufuta hifadhi ya programu."</string>
    <string name="computing_size" msgid="4915310659841174866">"Inahesabu..."</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Haikuweza kuhesabu ukubwa wa furushi."</string>
    <string name="version_text" msgid="7628938665256107608">"Toleo <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Songa"</string>
    <string name="archiving_failed" msgid="2037798988961634978">"Imeshindwa kuhifadhi kwenye kumbukumbu"</string>
    <string name="archiving_succeeded" msgid="7891249456483297845">"Kwenye kumbukumbu: <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="restoring_failed" msgid="3390531747355943533">"Imeshindwa kurejesha"</string>
    <string name="restoring_in_progress" msgid="7787443682651146115">"Inarejesha <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"Tayari kuna uhamishaji unaoendelea."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"Nafasi ya hifadhi haitoshi."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"Programu haipo."</string>
    <string name="invalid_location" msgid="8013853455355520557">"Eneo la kusakinisha si halali."</string>
    <string name="system_package" msgid="7559476279008519360">"Sasisho za mfumo haziwezi kusakinisha kwa media ya nje."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Huwezi kusakinisha programu ya msimamizi wa kifaa kwenye kifaa cha nje"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Ungependa kuilazimisha ikome?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Ukiilazimisha programu ikome, huenda ikakosa kufanya kazi vizuri."</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Zima programu"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"Ukizima programu hii, huenda Android na programu zingine zikakosa kufanya kazi tena kama ilivyokusudiwa. Kumbuka, huwezi kufuta programu hii kwa kuwa ilisakinishwa mapema kwenye kifaa chako. Kwa kuizima, unazima programu hii na kuificha kwenye kifaa chako."</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Duka"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Maelezo ya programu"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"Programu imesakinishwa kutoka <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Maelezo zaidi kwenye <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"Inatumika"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Haijawahi kutumiwa)"</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Matumizi ya hifadhi"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Inawasha upya"</string>
    <string name="cached" msgid="5379485147573438201">"Mchakato unaoendelea chinichini ulioakibishwa"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Hakuna uendeshaji."</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Imeanzishwa na programu."</string>
    <!-- no translation found for service_client_name (2210898622981598861) -->
    <skip />
    <string name="service_background_processes" msgid="2800539421534521948">"Hujatumia <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"Umetumia <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory" msgid="5253757199926592074">"RAM"</string>
    <!-- no translation found for service_process_name (7827318358399776412) -->
    <skip />
    <string name="running_process_item_user_label" msgid="1444898861984132133">"Mtumiaji: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Mtumiaji aliyeondolewa"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"Mchakato <xliff:g id="NUMPROCESS">%1$d</xliff:g> na huduma <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_s_p" msgid="1209371773353932361">"Mchakato <xliff:g id="NUMPROCESS">%1$d</xliff:g> na huduma <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_p_s" msgid="8957061449107822282">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> shughulikia na <xliff:g id="NUMSERVICES">%2$d</xliff:g> huduma"</string>
    <string name="running_processes_item_description_p_p" msgid="3292999232897469679">"Michakato <xliff:g id="NUMPROCESS">%1$d</xliff:g> na huduma <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Kumbukumbu ya kifaa"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"Matumizi ya RAM  ya programu"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"Mfumo"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Programu"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Bila malipo"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Imetumika"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"Iliyo kwenye akiba"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> ya RAM"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Programu inayotumika"</string>
    <string name="no_services" msgid="3898812785511572899">"Sio amilifu"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Huduma"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Shughuli"</string>
    <string name="service_stop" msgid="5712522600201308795">"Acha"</string>
    <string name="service_manage" msgid="3896322986828332075">"Mipangilio"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"Huduma hii ilianzishwa na programu yake. Kuisitisha kunaweza kuifanya programu iache kufanya kazi."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"Programu hii haiwezi kusitishwa kwa usalama. Ukiisitisha, unaweza kupoteza baadhi ya kazi yako ya sasa."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"Hii ni utaratibu wa zamani ya programu ambayo bado inaendeshwa iwapo itahitajika tena. Huwa hakuna sababu ya kuisitisha."</string>
    <string name="service_manage_description" msgid="6615788996428486121">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: inatumika kwa sasa. Gusa Mipangilio ili uidhibiti."</string>
    <string name="main_running_process_description" msgid="6685973937935027773">"Utaratibu kuu ambao unatumika."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"Huduma inatumika <xliff:g id="COMP_NAME">%1$s</xliff:g>"</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"Mtoaji huduma <xliff:g id="COMP_NAME">%1$s</xliff:g> anatumika"</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Komesha huduma ya mfumo?"</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Lugha, vifaa vya kuingiza data na ishara"</string>
    <string name="language_settings" msgid="8700174277543875046">"Lugha na uingizaji data"</string>
    <string name="languages_settings" msgid="5784775502251770671">"Lugha"</string>
    <string name="keyboard_settings" msgid="184185708597386454">"Kibodi"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Huna ruhusa ya kubadilisha lugha inayotumika kwenye kifaa."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Lugha na uingizaji data"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Zana"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Kibodi na mbinu za kuingiza hoja"</string>
    <string name="system_language" msgid="1146762166579643257">"Lugha za mfumo"</string>
    <string name="phone_language" msgid="5986939176239963826">"Lugha"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Weka mibadala kiotomatiki"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Sahihisha maneno yaliyochapwa vibaya"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Ukozaji-kioto"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Sentensi zianze kwa herufi kubwa"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Akifisha kiotomaki"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Mipangilio ya kibodi halisi"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Bonyeza kibonye cha \'Space\' mara mbili ili uweke \".\""</string>
    <string name="show_password" msgid="7101900779571040117">"Onyesha manenosiri"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Onyesha herufi kwa muda mfupi unapoandika"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"Kikagua tahajia hiki kinaweza kukusanya maandishi yote wakati unaandika, ikiwemo data ya binafsi kama manenosiri na namba za kadi za mikopo. Kinatoka kwa programu ya <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Ungependa kutumia kikagua tahajia hiki?"</string>
    <string name="spellchecker_quick_settings" msgid="6449414356743946577">"Mipangilio"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Lugha"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Kibodi"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Kibodi ya skrini"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Kibodi ya skrini Inayopatikana"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Dhibiti kibodi za skrini"</string>
    <string name="keyboard_options_category" msgid="8040137073401152608">"Chaguo"</string>
    <string name="keyboard_a11y_category" msgid="8230758278046841469">"Ufikivu"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Kibodi halisi"</string>
    <string name="show_ime" msgid="4334255501724746849">"Tumia kibodi ya skrini"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Ionyeshe kwenye skrini wakati kibodi halisi inatumika"</string>
    <string name="bounce_keys" msgid="7419450970351743904">"Vitufe vinavyoduta"</string>
    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
    <skip />
    <string name="slow_keys" msgid="2891452895499690837">"Vitufe vya polepole"</string>
    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
    <skip />
    <string name="sticky_keys" msgid="7317317044898161747">"Vitufe vinavyonata"</string>
    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
    <skip />
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Mikato ya kibodi"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Onyesha orodha ya njia za mkato"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Zana na kibodi za wasifu wa kazini"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Kibodi ya skrini ya kazini"</string>
    <string name="keyboard_default_layout" msgid="5377811770620422301">"Chaguomsingi"</string>
    <string name="trackpad_settings" msgid="2071131324087677005">"Padi ya kugusa"</string>
    <string name="trackpad_mouse_settings" msgid="136226693583218429">"Padi ya kugusa na kipanya"</string>
    <string name="trackpad_settings_summary" msgid="3369855644136760402">"Kasi ya kiashiria, ishara"</string>
    <string name="trackpad_tap_to_click" msgid="1938230946542070746">"Gusa ili ubofye"</string>
    <string name="trackpad_touchpad_gesture_title" msgid="7568052847609914436">"Ishara za padi ya kugusa"</string>
    <string name="trackpad_touchpad_gesture_summary" msgid="6256074591395359124">"Weka mapendeleo kwenye ishara maalum za kusogeza za padi ya kugusa"</string>
    <string name="trackpad_reverse_scrolling_title" msgid="422877284529360866">"Usogezaji kinyume"</string>
    <string name="trackpad_reverse_scrolling_summary" msgid="6048648562887499036">"Maudhui husogea juu unaposogeza chini"</string>
    <string name="trackpad_bottom_right_tap_title" msgid="6275428879042702880">"Mguso wa chini kulia"</string>
    <string name="trackpad_bottom_right_tap_summary" msgid="8734094086900680674">"Gusa kona ya upande wa chini kulia wa padi ya kugusa kwa chaguo zaidi"</string>
    <string name="trackpad_pointer_speed" msgid="7786579408631352625">"Kasi ya kiashiria"</string>
    <string name="trackpad_touch_gesture" msgid="8641725062131922497">"Jifunze ishara za padi ya kugusa"</string>
    <string name="keywords_touchpad" msgid="8159846254066666032">"padi ya kusogeza, padi ya kusogeza, kipanya, kiteuzi, nenda, telezesha kidole, bofya kulia, bofya, kishale"</string>
    <string name="keywords_trackpad_bottom_right_tap" msgid="1285062446073929305">"bofya kulia, gusa"</string>
    <string name="gesture_title_go_home" msgid="3682238648647225933">"Nenda kwenye ukurasa wa mwanzo"</string>
    <string name="gesture_summary_go_home" msgid="6409031586904205741">"Telezesha vidole vitatu juu popote kwenye padi yako ya kugusa"</string>
    <string name="gesture_title_go_back" msgid="6619462058488419802">"Rudi nyuma"</string>
    <string name="gesture_summary_go_back" msgid="4981604277892236888">"Telezesha vidole vitatu kutoka kulia au kushoto"</string>
    <string name="gesture_title_recent_apps" msgid="6082688963233208761">"Angalia programu za hivi karibuni"</string>
    <string name="gesture_summary_recent_apps" msgid="6643179135202417509">"Telezesha vidole vitatu juu, shikilia kisha uachilie"</string>
    <string name="gesture_title_notifications" msgid="791717222472350194">"Angalia arifa na Mipangilio ya Haraka"</string>
    <string name="gesture_summary_notifications" msgid="8419514601638387255">"Telezesha vidole vitatu chini kwenye skrini yako ya kwanza"</string>
    <string name="gesture_title_switch_apps" msgid="5840994412037872157">"Badilisha programu"</string>
    <string name="gesture_summary_switch_apps" msgid="6842648062151413042">"Telezesha vidole vinne kulia au kushoto"</string>
    <string name="gesture_button_skip" msgid="5174842083451193213">"Ruka"</string>
    <string name="gesture_button_next" msgid="695288092704187356">"Inayofuata"</string>
    <string name="gesture_button_restart" msgid="1895850891992530133">"Anza upya"</string>
    <string name="gesture_button_done" msgid="6387900351203032188">"Nimemaliza"</string>
    <string name="trackpad_go_back_title" msgid="5312164160947491440">"Rudi nyuma"</string>
    <string name="trackpad_go_back_summary" msgid="4201901101085902768">"Telezesha vidole vitatu kulia au kushoto"</string>
    <string name="trackpad_go_home_title" msgid="2146525662148291552">"Nenda kwenye ukurasa wa mwanzo"</string>
    <string name="trackpad_go_home_summary" msgid="2222744701528360887">"Telezesha vidole vitatu juu"</string>
    <string name="trackpad_recent_apps_title" msgid="8195970908411585445">"Programu za hivi karibuni"</string>
    <string name="trackpad_recent_apps_summary" msgid="2685092851677573794">"Telezesha vidole vitatu juu kisha ushikilie"</string>
    <string name="trackpad_notifications_title" msgid="3521663305043747880">"Arifa"</string>
    <string name="trackpad_notifications_summary" msgid="7663647367648690040">"Telezesha vidole vitatu chini"</string>
    <string name="trackpad_switch_apps_title" msgid="7342032935377284039">"Badilisha programu"</string>
    <string name="trackpad_switch_apps_summary" msgid="9193942041912927440">"Telezesha vidole vinne kulia au kushoto"</string>
    <string name="modifier_keys_settings" msgid="2537108435032034683">"Vitufe vya kurekebisha"</string>
    <string name="modifier_keys_settings_summary" msgid="6933143361657444436">"Badilisha utendaji wa vitufe vya kurekebisha"</string>
    <string name="modifier_keys_reset_title" msgid="948294258402761066">"Badilisha vyote"</string>
    <string name="modifier_keys_default_summary" msgid="8701640508670973258">"Chaguomsingi"</string>
    <string name="modifier_keys_reset_message" msgid="5236994817619936058">"Una uhakika unataka kuweka upya mipangilio chaguomsingi ya vitufe vyote vya kurekebisha?"</string>
    <string name="modifier_keys_done" msgid="8196199314913909700">"Nimemaliza"</string>
    <string name="modifier_keys_cancel" msgid="7136520252570826772">"Ghairi"</string>
    <string name="modifier_keys_reset" msgid="551170906710422041">"Weka upya"</string>
    <string name="modifier_keys_picker_title" msgid="244545904150587851">"Chagua kitufe cha kurekebisha"</string>
    <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Chagua kitufe kipya cha kurekebisha cha <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"Chaguomsingi"</string>
    <string name="speech_category_title" msgid="5995161659186229742">"Kutamka"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Kasi ya kiashiria"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Kidhibiti cha Mchezo"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Elekeza mtetemo"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Elekeza mitetemo kwenye kidhibiti cha mchezo wakati kimeunganishwa"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Chagua mpangilio wa kibodi"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"sanidi mipangilio ya kibodi"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Ili kubadili, bonyeza Dhibiti-Kiweka nafasi"</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Chaguomsingi"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Mpangilio wa kibodi"</string>
    <string name="keyboard_layout_picker_category_title" msgid="2369473692906329772">"Miundo ya kibodi halisi"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Kamusi binafsi"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Kamusi ya binafsi ya kazini"</string>
    <string name="user_dict_settings_summary" msgid="4939694372338975081">"Weka maneno ya kutumiwa katika programu kama vile Kikagua maendelezo"</string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Ongeza"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Ongeza kwenye kamusi"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Fungu la maneno"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Chaguo zaidi"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Chaguo chache"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"SAWA"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Neno:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Njia mkato:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Lugha:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Andika neno"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Mkato wa hiari"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Hariri Neno"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Hariri"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Futa"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"Huna maneno yoyote katika kamusi ya mtumiaji. Gusa kitufe cha Ongeza (+) ili uongeze neno."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"Ya lugha zote"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Lugha zaidi..."</string>
    <string name="testing" msgid="6294172343766732037">"Majaribio"</string>
    <string name="keyboard_settings_summary" msgid="9188442758316476986">"Kibodi ya skrini, zana"</string>
    <string name="keyboard_settings_with_physical_keyboard_summary" msgid="2240779804018260938">"Kibodi ya skrini, kibodi halisi, zana"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Kibodi halisi"</string>
    <string name="enabled_locales_keyboard_layout" msgid="3939886151098958639">"Muundo"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Chagua kitufe"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Chagua wijeti"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Unda wijeti na uruhusu ufikiaji?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5825298768068148804">"Baada ya kuunda wijeti, programu inaweza kufikia kila kitu kinachoonyeshwa.\n\nProgramu: <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g>\nWijeti: <xliff:g id="WIDGET_LABEL">%2$s</xliff:g>\n"</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7268758525344468364">"Daima ruhusu <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> kuunda wijeti na kufikia data yao"</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Takwimu za utumiaji"</string>
    <string name="usage_stats_sort_by_usage_time" msgid="2927310334119998301">"Panga kulingana na muda wa matumizi"</string>
    <string name="usage_stats_sort_by_last_time_used" msgid="7039213339779884017">"Panga kulingana na mara ya mwisho kutumika"</string>
    <string name="usage_stats_sort_by_app_name" msgid="4463833145514850478">"Panga kulingana na jina la programu"</string>
    <string name="last_time_used_label" msgid="7589377271406011659">"Mwisho kutumika"</string>
    <string name="last_time_used_never" msgid="2936073559267990034">"hazijawahi kufunguliwa"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Muda wa utumiaji"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Ufikivu"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Mipangilio ya ufikiaji"</string>
    <string name="accessibility_settings_summary" msgid="2366627644570558503">"Onyesho, utumiaji, sauti"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Mipangilio ya Kuona"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"Unaweza kubadilisha mipangilio ya kifaa hiki kulingana na mahitaji yako. Vipengele hivi vya ufikivu vinaweza kubadilishwa baadaye kwenye Mipangilio."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Badilisha ukubwa wa fonti"</string>
    <string name="screen_reader_category_title" msgid="5825700839731107803">"Kisoma skrini"</string>
    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
    <skip />
    <string name="captions_category_title" msgid="574490148949400274">"Manukuu"</string>
    <string name="audio_category_title" msgid="5283853679967605826">"Sauti"</string>
    <string name="general_category_title" msgid="6298579528716834157">"Jumla"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Skrini"</string>
    <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Rangi na picha katika mwendo"</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">"Geuza skrini iwe nyeusi"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Vidhibiti vya mawasiliano"</string>
    <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Vidhibiti vya muda"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Vidhibiti vya mfumo"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Programu ulizopakua"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Ya majaribio"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Alama za vipengele"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_title" msgid="401330708633716596">"Kuchuja data ya kumbukumbu ya Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_summary" msgid="1319792184194176235">"Weka vichujio"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_footer" msgid="4158945851818483666">"Zima na uwashe Bluetooth ili mabadiliko yaanze kutumika"</string>
    <string name="bt_hci_snoop_log_filter_pbap_title" msgid="1735427364451634823">"PBAP ya kuchuja kumbukumbu ya data ya kudukiza Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filter_map_title" msgid="180092480793945544">"RAMANI ya kuchuja kumbukumbu ya data ya kudukiza Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filter_summary" msgid="7217091930762522599">"Weka hali ya kuchuja. (Zima na uwashe Bluetooth ili mabadiliko yaanze kutumika)"</string>
    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary" msgid="8824952559433361848">"Weka hali ya kumbukumbu ya data Bluetooth HCI ili Uruhusu Vichujio vibadilishe chaguo hili"</string>
    <string name="talkback_title" msgid="8756080454514251327">"Talkback"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Kisoma skrini hasa kwa watu wenye upofu na wenye matatizo ya kuona"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Gusa vipengee kwenye skrini yako ili usikie vikisomwa kwa sauti"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Mapendeleo ya manukuu"</string>
    <string name="accessibility_captioning_about_title" msgid="3542171637334191563">"Kuhusu mapendeleo ya manukuu"</string>
    <string name="accessibility_captioning_footer_learn_more_content_description" msgid="5730040700677017706">"Pata maelezo zaidi kuhusu mapendeleo ya manukuu"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Ukuzaji"</string>
    <string name="accessibility_screen_magnification_shortcut_title" msgid="2387963646377987780">"Njia ya mkato ya ukuzaji"</string>
    <string name="accessibility_screen_magnification_follow_typing_title" msgid="6379517513916651560">"Kukuza unapoandika"</string>
    <string name="accessibility_screen_magnification_follow_typing_summary" msgid="2882250257391761678">"Kikuza skrini hufuata maandishi unapoandika"</string>
    <string name="accessibility_screen_magnification_always_on_title" msgid="3814297443759580936">"Kisizime unapobadili programu"</string>
    <string name="accessibility_screen_magnification_always_on_summary" msgid="306908451430863049">"Kikuzaji hakizimi na husogeza mbali unapobadili programu"</string>
    <string name="accessibility_screen_magnification_joystick_title" msgid="1803769708582404964">"Usukani"</string>
    <string name="accessibility_screen_magnification_joystick_summary" msgid="4640300148573982720">"Washa na usogeze kikuza skrini kwa kutumia usukani wa kwenye skrini. Gusa na ushikilie, kisha uburute kwenye usukani ili udhibiti kikuza skrini. Gusa na uburute ili kusogeza usukani pekee."</string>
    <string name="accessibility_screen_magnification_about_title" msgid="8857919020223505415">"Kuhusu ukuzaji"</string>
    <string name="accessibility_screen_magnification_footer_learn_more_content_description" msgid="924848332575978463">"Pata maelezo zaidi kuhusu ukuzaji"</string>
    <string name="accessibility_magnification_mode_title" msgid="8446475127807168063">"Aina ya ukuzaji"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="8498648925928109462">"Kuza skrini yako nzima, sehemu mahususi au ubadilishe kati ya chaguo zote mbili"</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Skrini nzima"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="9191632962955877019">"Sehemu ya skrini"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="8107511976748799455">"Badilisha kati ya skrini kamili na sehemu ya skrini"</string>
    <string name="accessibility_magnification_mode_dialog_title" msgid="9151027667059878578">"Chagua jinsi ya kukuza"</string>
    <string name="accessibility_magnification_mode_dialog_option_full_screen" msgid="4892487869954032029">"Kuza skrini nzima"</string>
    <string name="accessibility_magnification_mode_dialog_option_window" msgid="4492443201099153362">"Kuza sehemu ya skrini"</string>
    <string name="accessibility_magnification_mode_dialog_option_switch" msgid="561043521011229424">"Badilisha kati ya skrini kamili na sehemu ya skrini"</string>
    <string name="accessibility_magnification_area_settings_mode_switch_summary" msgid="2885238806099080966">"Gusa kitufe cha kubadilisha ili usogeze kati ya chaguo zote mbili"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Utabadili ili utumie kitufe cha zana za ufikivu?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="7718653917415163833">"Kutumia kipengele cha kugusa mara tatu ili kukuza sehemu ya skrini yako huchelewesha kuandika na vitendo vingine.\n\nKitufe cha zana za ufikivu huelea juu ya programu zingine kwenye skrini yako. Kiguse ili ukuze."</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Badilisha utumie kitufe cha zana za ufikivu"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="7115794462123071594">"Tumia kipengele cha kugusa mara tatu"</string>
    <string name="accessibility_magnification_triple_tap_warning_title" msgid="8484669851397296597">"Huenda hali hii ikapunguza kasi ya kibodi yako"</string>
    <string name="accessibility_magnification_triple_tap_warning_message" msgid="2008671502848936410">"Unapotumia kipengele cha kugusa mara tatu ili kukuza sehemu ya skrini yako, huenda ukatambua hitilafu kwenye kibodi.\n\nIli uepuke hali hii, unaweza kubadilisha njia yako ya mkato ya ukuzaji kutoka kugusa mara tatu na utumie chaguo lingine.\n"<annotation id="link">"Badilisha mipangilio"</annotation></string>
    <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Endelea tu"</string>
    <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Ghairi"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Mipangilio ya ukuzaji"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Kuza kwa njia ya mkato"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Kuza ukitumia njia ya mkato na kugonga mara tatu"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"Kuhusu <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_text_reading_options_title" msgid="3224648909213325563">"Ukubwa wa vipengee na maandishi"</string>
    <string name="accessibility_text_reading_options_suggestion_title" msgid="2492155642665312733">"Badilisha jinsi maandishi yanavyoonekana"</string>
    <string name="accessibility_text_reading_preview_mail_subject" msgid="4597374768612733616">"Mada: Miundo ya Puto la hewa joto"</string>
    <string name="accessibility_text_reading_preview_mail_from" msgid="1797499780365288020">"Kutoka kwa: Bill"</string>
    <string name="accessibility_text_reading_preview_mail_content" msgid="8078152365771951802">"Habari za asubuhi!\n\nNilitaka kufahamu miundo imefikia wapi. Je, itakuwa tayari kabla hatujaanza kutengeneza maputo mapya?"</string>
    <string name="accessibility_text_reading_reset_button_title" msgid="5960753279788187669">"Badilisha mipangilio"</string>
    <string name="accessibility_text_reading_reset_message" msgid="824644303661026712">"Mipangilio ya ukubwa wa vipengee na maandishi imebadilishwa"</string>
    <string name="accessibility_text_reading_confirm_dialog_title" msgid="2865331351355690389">"Ungependa kubadilisha ukubwa wa vipengee na maandishi?"</string>
    <string name="accessibility_text_reading_confirm_dialog_reset_button" msgid="8215800137850243736">"Weka upya"</string>
    <string name="accessibility_text_reading_conversation_message_1" msgid="7883952203831957831">"Una mipango yoyote ya wikendi?"</string>
    <string name="accessibility_text_reading_conversation_message_2" msgid="8112160435318635856">"Ninaelekea ufukweni. Ungependa kuja?"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Chaguo"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Vuta karibu kwenye skrini"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Gusa mara 3 ili ukuze"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Gusa kitufe ili ukuze"</string>
    <string name="accessibility_screen_magnification_intro_text" msgid="3856180549393526339">"Vuta karibu kwa haraka kwenye skrini ili ufanye maudhui yawe makubwa"</string>
    <string name="accessibility_screen_magnification_summary" msgid="8267672508057326959">"&lt;b&gt;Ili uvute karibu:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Tumia njia ya mkato ili uanze kukuza&lt;br/&gt; {1,number,integer}. Gusa skrini&lt;br/&gt; {2,number,integer}. Buruta vidole viwili ili usogeze kwenye skrini&lt;br/&gt; {3,number,integer}. Bana kwa vidole viwili ili ubadilishe ukuzaji&lt;br/&gt; {4,number,integer}. Tumia njia ya mkato ili uache kukuza&lt;br/&gt;&lt;br/&gt;&lt;b&gt;Ili uvute karibu kwa muda:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Hakikisha umechagua aina ya ukuzaji kuwa skrini nzima&lt;br/&gt; {1,number,integer}. Tumia njia ya mkato ili uanze kukuza&lt;br/&gt; {2,number,integer}. Gusa na ushikilie mahali popote kwenye skrini&lt;br/&gt; {3,number,integer}. Buruta kidole ili usogeze kwenye skrini&lt;br/&gt; {4,number,integer}. Inua kidole ili uache kukuza"</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Ukiwasha ukuzaji, unaweza kuvuta karibu kwenye skrini yako.\n\n"<b>"Ili ukuze"</b>", anzisha ukuzaji kisha uguse mahali popote kwenye skrini.\n"<ul><li>"Buruta vidole 2 au zaidi ili usogeze"</li>\n<li>"Bana vidole 2 au zaidi ili urekebishe ukuzaji"</li></ul>\n\n<b>"Ili ukuze kwa muda"</b>", anzisha ukuzaji kisha uguse na ushikilie mahali popote kwenye skrini.\n"<ul><li>"Buruta ili usogeze kwenye skrini"</li>\n<li>"Inua kidole ili usogeze mbali"</li></ul>\n\n"Huwezi kuvuta karibu kwenye kibodi au sehemu ya viungo muhimu."</string>
    <string name="accessibility_tutorial_pager" msgid="8461939455728454061">"Ukurasa wa <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> kati ya <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Tumia kitufe cha ufikivu kufungua"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Shikilia vitufe vya sauti ili ufungue"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Gusa skrini mara tatu ili ufungue"</string>
    <string name="accessibility_tutorial_dialog_title_two_finger_double" msgid="3912970760484557646">"Gusa skrini mara mbili kwa vidole viwili ili ufungue"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Tumia ishara ili ufungue"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="6800684770875867559">"Tumia ishara ya ufikivu"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Ili utumie kipengele hiki, gusa kitufe cha zana za ufikivu cha <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> katika sehemu ya chini ya skrini yako.\n\nIli ubadilishe kati ya vipengele, gusa na ushikilie kitufe cha zana za ufikivu."</string>
    <string name="accessibility_tutorial_dialog_message_floating_button" msgid="2551777208185138391">"Ili utumie kipengele hiki, gusa kitufe cha zana za ufikivu kwenye skrini yako."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Ili utumie kipengele hiki, bonyeza na ushikilie vitufe vyote viwili vya sauti."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Ili uanzishe na kusimamisha ukuzaji, gusa mara tatu mahali popote kwenye skrini yako."</string>
    <string name="accessibility_tutorial_dialog_message_two_finger_triple" msgid="860548190334486449">"Ili uanze au ukomeshe ukuzaji, gusa mara mbili mahali popote kwenye skrini yako kwa vidole viwili."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Ili utumie kipengele hiki, telezesha vidole viwili juu kutoka sehemu ya chini ya skrini.\n\nIli ubadilishe kati ya vipengele, telezesha vidole viwili juu na ushikilie."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Ili utumie kipengele hiki, telezesha vidole vitatu juu kutoka sehemu ya chini ya skrini.\n\nIli ubadilishe kati ya vipengele, telezesha vidole vitatu juu na ushikilie."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Ili utumie kipengele cha ufikivu, telezesha vidole viwili juu kutoka sehemu ya chini ya skrini.\n\nIli ubadilishe kati ya vipengele, telezesha vidole viwili juu na ushikilie."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Ili utumie kipengele cha ufikivu, telezesha vidole vitatu juu kutoka sehemu ya chini ya skrini.\n\nIli ubadilishe kati ya vipengele, telezesha vidole vitatu juu na ushikilie."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"Nimeelewa"</string>
    <string name="accessibility_tutorial_dialog_link_button" msgid="6797349445794031781">"Mipangilio ya kitufe"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"Njia mkato ya <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Kitufe cha zana za ufikivu"</string>
    <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Ishara ya ufikivu"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Telezesha vidole viwili juu"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Telezesha vidole vitatu juu"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Gusa kitufe cha zana za ufikivu"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture" msgid="3981188764050497346">"Tumia ishara ya ufikivu"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Gusa kitufe cha zana za ufikivu cha <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> kilicho sehemu ya chini ya skrini yako.\n\nIli ubadilishe kati ya vipengele, gusa na ushikilie kitufe cha zana za ufikivu."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Telezesha vidole viwili juu kutoka sehemu ya chini ya skrini.\n\nIli ubadilishe kati ya vipengele, telezesha vidole viwili juu na ushikilie."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Telezesha vidole vitatu juu kutoka sehemu ya chini ya skrini.\n\nIli ubadilishe kati ya vipengele, telezesha vidole vitatu juu na ushikilie."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating" msgid="4459254227203203324"><annotation id="link">"Chaguo zaidi"</annotation></string>
    <string name="footer_learn_more_content_description" msgid="8843798273152131341">"Pata maelezo zaidi kuhusu <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Shikilia vitufe vya sauti"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"shikilia vitufe vya sauti"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Bonyeza na ushikilie vitufe vyote viwili vya sauti"</string>
    <string name="accessibility_shortcut_edit_dialog_title_two_finger_double_tap" msgid="2271778556854020996">"Gusa skrini mara mbili kwa vidole viwili"</string>
    <string name="accessibility_shortcut_two_finger_double_tap_keyword" msgid="2971265341474137433">"gusa skrini mara mbili kwa vidole viwili"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_two_finger_double_tap" msgid="8262165091808318538">"Gusa skrini kwa haraka mara {0,number,integer} kwa vidole viwili"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Gusa skrini mara tatu"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"gusa skrini mara tatu"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="2102327956423320536">"Gusa skrini mara {0,number,integer} kwa haraka. Huenda njia hii ya mkato ikapunguza kasi ya kifaa chako"</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Mipangilio ya kina"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"Kitufe cha zana za walio na matatizo ya kuona au kusikia kimewekwa kuwa <xliff:g id="SERVICE">%1$s</xliff:g>. Gusa na ushikilie Kitufe cha zana za walio na matatizo ya kuona au kusikia, kisha uchague ukuzaji ili utumie kipengele cha ukuzaji."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"Ishara ya zana za walio na matatizo ya kuona au kusikia imewekwa kwenye <xliff:g id="SERVICE">%1$s</xliff:g>. Ili utumie ukuzaji, telezesha vidole viwili kutoka chini kwenda juu kwenye skrini na ushikilie. Kisha uchague ukuzaji."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Mkato wa kitufe cha sauti"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Mipangilio ya njia ya mkato"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Njia ya mkato kwenye skrini iliyofungwa"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Ruhusu kipengele cha njia ya mkato ya kufikia vipengele kiwake kwenye skrini iliyofungwa. Shikilia vitufe vyote viwili vya sauti kwa sekunde chache."</string>
    <string name="accessibility_button_title" msgid="5251235485581552614">"Kitufe cha zana za ufikivu"</string>
    <string name="accessibility_button_gesture_title" msgid="3573456209050374139">"Ishara na kitufe cha zana za ufikivu"</string>
    <string name="accessibility_button_intro_text" msgid="80993874471745687">"Fikia vipengele vya ufikivu kwa haraka kutoka kwenye skrini yoyote"</string>
    <string name="accessibility_button_about_title" msgid="3581116105084067926">"Kuhusu kitufe cha zana za ufikivu"</string>
    <string name="accessibility_button_gesture_about_title" msgid="8468987303602865536">"Kuhusu ishara na kitufe cha zana za ufikivu"</string>
    <string name="accessibility_button_gesture_footer_learn_more_content_description" msgid="4144803517680297869">"Pata maelezo zaidi kuhusu ishara na kitufe cha zana za ufikivu"</string>
    <string name="accessibility_button_intro" msgid="2601976470525277903">"Kutumia kitufe cha zana za ufikivu. Ishara haipatikani kwenye usogezaji kwa kutumia vitufe 3."</string>
    <string name="accessibility_button_summary" msgid="8510939012631455831">"Fikia vipengele vya ufikivu haraka"</string>
    <string name="accessibility_button_gesture_description" msgid="1141723096904904336">"&lt;b&gt;Ili uanze&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Nenda kwenye mipangilio ya ufikivu&lt;br/&gt; {1,number,integer}. Teua kipengele kisha uguse njia ya mkato&lt;br/&gt; {2,number,integer}. Chagua ikiwa ungependa kutumia kitufe au ishara kufikia kipengele&lt;br/&gt;"</string>
    <string name="accessibility_button_description" msgid="7669538706120092399">"&lt;b&gt;Ili uanze&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Nenda kwenye mipangilio ya ufikivu&lt;br/&gt; {1,number,integer}. Teua kipengele kisha uguse njia ya mkato&lt;br/&gt; {2,number,integer}. Chagua kitufe ili ufikie kipengele&lt;br/&gt;"</string>
    <string name="accessibility_button_or_gesture_title" msgid="3510075963401163529">"Tumia ishara au kitufe"</string>
    <string name="accessibility_button_location_title" msgid="7182107846092304942">"Mahali"</string>
    <string name="accessibility_button_size_title" msgid="5785110470538960881">"Ukubwa"</string>
    <string name="accessibility_button_fade_title" msgid="8081993897680588829">"Fifia wakati hakitumiki"</string>
    <string name="accessibility_button_fade_summary" msgid="7865950833524973709">"Hufifia baada ya sekunde chache na kuifanya iwe rahisi kuona skrini yako"</string>
    <string name="accessibility_button_opacity_title" msgid="4727355657530362289">"Kupenyeza mwangaza wakati hakitumiki"</string>
    <string name="accessibility_button_low_label" msgid="4193015407828927741">"Kupenyeza mwangaza"</string>
    <string name="accessibility_button_high_label" msgid="9138077512008190896">"Kutopenyeza mwangaza"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Maandishi yenye utofautishaji bora"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Badilisha rangi ya maandishi kuwa nyeusi au nyeupe. Ongeza utofautishaji ukitumia mandharinyuma."</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">"Sasisha otomatiki ukuzaji wa skrini"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Sasisha ukuzaji wa skrini kwenye mipito ya  programu"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Kata simu kwa kitufe cha kuwasha/kuzima"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Kielekezi kikubwa cha kipanya"</string>
    <string name="accessibility_toggle_large_pointer_icon_summary" msgid="1480527946039237705">"Fanya kiashiria cha kipanya kionekane kwa urahisi zaidi"</string>
    <string name="accessibility_force_invert_title" msgid="5015366813138748407">"Fanya programu zote ziwe na mandhari meusi"</string>
    <string name="accessibility_force_invert_summary" msgid="1882329675950887268">"Inatumika kwa programu zisizo na mandhari meusi. Baadhi ya programu zinaweza kuwa na matatizo ya kuonyeshwa, kama vile rangi zilizogeuzwa."</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Ondoa uhuishaji"</string>
    <string name="accessibility_disable_animations_summary" msgid="5828228669556554565">"Punguza mwendo kwenye skrini"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Sauti ya mono"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Unganisha vituo unapocheza sauti"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Usawazishaji wa sauti"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Kushoto"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Kulia"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Chaguomsingi"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"Sekunde 10"</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"Sekunde 30"</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"Dakika 1"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"Dakika 2"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Chukua hatua (Muda wa Ufikivu umekwisha)"</string>
    <string name="accessibility_control_timeout_about_title" msgid="813588002683460837">"Kuhusu muda wa kuchukua hatua (Kuisha kwa muda wa ufikivu)"</string>
    <string name="accessibility_control_timeout_footer_learn_more_content_description" msgid="8118584413220542193">"Pata maelezo zaidi kuhusu muda wa kuchukua hatua (Kuisha kwa muda wa ufikivu)"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Wakati wa kuchukua hatua"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="4037051091059316310">"Mapendeleo haya ya kuweka muda hayatumiki katika programu zote"</string>
    <string name="accessibility_control_timeout_preference_intro_text" msgid="1398116710556762245">"Chagua muda ambao ungependa kuonyesha ujumbe wa muda unaokuomba uchukue hatua"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Muda wa kugusa na kushikilia"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Ugeuzaji rangi"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Tumia ugeuzaji rangi"</string>
    <string name="accessibility_display_inversion_shortcut_title" msgid="6889624526691513462">"Njia ya mkato ya ugeuzaji rangi"</string>
    <string name="accessibility_display_inversion_preference_intro_text" msgid="1159663288481145318">"Ugeuzaji rangi hubadilisha skrini zenye mwangaza kuwa nyeusi. Pia hubadilisha skrini nyeusi kuwa zenye mwangaza."</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="4494767676482389509">"&lt;b&gt;Kumbuka&lt;/b&gt;&lt;br/&gt; &lt;ol&gt; &lt;li&gt; Rangi zitabadilika kwenye maudhui na picha&lt;/li&gt; &lt;li&gt; Ugeuzaji rangi unafanya kazi kwenye programu zote&lt;/li&gt; &lt;li&gt; Ili uonyeshe mandharinyuma meusi, Mandhari meusi yanaweza kutumika badala yake&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_action_label_panel_slice" msgid="1313725957071602932">"kwenda kwenye mipangilio"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Kubofya kiotomatiki (muda kabla ya kubofya kiotomatiki)"</string>
    <string name="accessibility_autoclick_about_title" msgid="152923024405552594">"Kuhusu kubofya kiotomatiki (muda kabla ya kubofya kiotomatiki)"</string>
    <string name="accessibility_autoclick_footer_learn_more_content_description" msgid="7056189627042350691">"Pata maelezo zaidi kuhusu kubofya kiotomatiki (muda kabla ya kubofya kiotomatiki)"</string>
    <string name="accessibility_autoclick_intro_text" msgid="8959680635470639347">"Unaweza kuweka mipangilio ya kipanya kilichounganishwa ili ubofye kiotomatiki wakati ambapo kiteuzi kinaacha kusogea kwa muda fulani"</string>
    <string name="accessibility_autoclick_description" msgid="6695732131412361101">"Kubofya kiotomatiki kunaweza kusaidia iwapo ni vigumu kubofya kipanya"</string>
    <string name="accessibility_autoclick_default_title" msgid="2024730028293793490">"Kubofya kiotomatiki kumezimwa"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Muda mfupi"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"Sekunde 0.2"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Wastani"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"Sekunde 0.6"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Muda mrefu"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"Sekunde 1"</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Maalum"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Mfupi zaidi"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Mrefu zaidi"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Muda wa kubofya kiotomatiki"</string>
    <string name="accessibility_vibration_settings_title" msgid="936301142478631993">"Mtetemo na miguso"</string>
    <string name="accessibility_vibration_settings_summary" msgid="3690308537483465527">"Dhibiti uthabiti wa mtetemo katika matumizi tofauti"</string>
    <string name="accessibility_vibration_settings_state_on" msgid="5566026932372832502">"Imewashwa"</string>
    <string name="accessibility_vibration_settings_state_off" msgid="7946588741954981703">"Imezimwa"</string>
    <string name="accessibility_vibration_setting_disabled_for_silent_mode_summary" msgid="3982701772953323190">"Mipangilio kimezimwa kwa sababu kifaa kimeondolewa sauti"</string>
    <string name="accessibility_call_vibration_category_title" msgid="2545607568768192318">"Simu"</string>
    <string name="accessibility_notification_alarm_vibration_category_title" msgid="2683635252414849417">"Arifa na kengele"</string>
    <string name="accessibility_interactive_haptics_category_title" msgid="3162855291184592021">"Mtetemo wa maudhui"</string>
    <string name="accessibility_vibration_primary_switch_title" msgid="6162579254864450592">"Tumia mtetemo na miguso"</string>
    <string name="accessibility_alarm_vibration_title" msgid="4661294337828522745">"Mtetemo wa kengele"</string>
    <string name="accessibility_media_vibration_title" msgid="1372073715403945428">"Mtetemo wa maudhui"</string>
    <string name="accessibility_keyboard_vibration_title" msgid="7559967730626765441">"Mtetemo wa kibodi"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Mtetemo wa mlio"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Mtetemo wa arifa"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Mtetemo kifaa kinapoguswa"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"Tumia <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"Fungua <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_auto_added_qs_tooltip_content" msgid="2941824314912928072">"<xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> imewekwa kwenye Mipangilio ya Haraka. Telezesha chini ili uwashe au uzime muda wowote."</string>
    <string name="accessibility_service_qs_tooltip_content" msgid="6002493441414967868">"Pia unaweza kuweka <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> kwenye Mipangilio ya Haraka katika sehemu ya juu ya skrini yako"</string>
    <string name="accessibility_color_correction_auto_added_qs_tooltip_content" msgid="9092661358437404374">"Usahihishaji wa rangi umewekwa kwenye Mipangilio ya Haraka. Telezesha chini ili uwashe au uzime muda wowote."</string>
    <string name="accessibility_color_correction_qs_tooltip_content" msgid="3258628434235475205">"Pia unaweza kuweka usahihishaji wa rangi kwenye Mipangilio ya Haraka katika upande wa juu wa skrini yako"</string>
    <string name="accessibility_color_inversion_auto_added_qs_tooltip_content" msgid="7267618234972101725">"Ugeuzaji rangi umewekwa kwenye Mipangilio ya Haraka. Telezesha chini ili uwashe au uzime muda wowote."</string>
    <string name="accessibility_color_inversion_qs_tooltip_content" msgid="5046332142185711869">"Pia unaweza kuweka ugeuzaji rangi kwenye Mipangilio ya Haraka katika upande wa juu wa skrini yako"</string>
    <string name="accessibility_reduce_bright_colors_auto_added_qs_tooltip_content" msgid="1906588335786328512">"Kipunguza mwangaza zaidi kimewekwa kwenye Mipangilio ya Haraka. Telezesha chini ili uwashe au uzime muda wowote."</string>
    <string name="accessibility_reduce_bright_colors_qs_tooltip_content" msgid="7522121299176176785">"Pia unaweza kuweka kipunguza mwangaza zaidi kwenye Mipangilio ya Haraka katika upande wa juu wa skrini yako"</string>
    <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content" msgid="7914554254280416532">"Hali ya kutumia kwa mkono mmoja imewekwa kwenye Mipangilio ya Haraka. Telezesha chini ili uwashe au uzime muda wowote."</string>
    <string name="accessibility_one_handed_mode_qs_tooltip_content" msgid="2754332083184384603">"Pia unaweza kuweka hali ya kutumia kwa mkono mmoja kwenye Mipangilio ya Haraka katika upande wa juu wa skrini yako"</string>
    <string name="accessibility_font_scaling_auto_added_qs_tooltip_content" msgid="7229921960884718332">"Ukubwa wa fonti umewekwa katika Mipangilio ya Haraka. Telezesha kidole chini ili ubadilishe ukubwa wa fonti muda wowote."</string>
    <string name="accessibility_quick_settings_tooltip_dismiss" msgid="3269120277643884190">"Ondoa"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Tumia kipengele cha usahihishaji wa rangi"</string>
    <string name="accessibility_daltonizer_shortcut_title" msgid="7480360363995502369">"Njia ya mkato ya usahihishaji wa rangi"</string>
    <string name="accessibility_daltonizer_about_title" msgid="6063650804116981287">"Kuhusu usahihishaji wa rangi"</string>
    <string name="accessibility_daltonizer_footer_learn_more_content_description" msgid="2091679253892040910">"Pata maelezo zaidi kuhusu usahihishaji wa rangi"</string>
    <string name="accessibility_color_inversion_about_title" msgid="8275754480247040136">"Kuhusu ugeuzaji rangi"</string>
    <string name="accessibility_color_inversion_footer_learn_more_content_description" msgid="5382579548498952445">"Pata maelezo zaidi kuhusu ugeuzaji rangi"</string>
    <string name="accessibility_captioning_primary_switch_title" msgid="3663677340286206100">"Onyesha manukuu"</string>
    <string name="accessibility_captioning_primary_switch_summary" msgid="2544094070306830218">"Kwa ajili ya programu inayotumika tu"</string>
    <string name="captioning_appearance_title" msgid="3128792092290011408">"Muundo na ukubwa wa manukuu"</string>
    <string name="captioning_appearance_summary" msgid="4620682807315588019">"Ukubwa wa maandishi <xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g>"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Chaguo zaidi"</string>
    <string name="accessibility_captioning_preference_intro" msgid="8995427146374031134">"Badilisha ukubwa na muundo wa manukuu ili iwe rahisi kusoma"</string>
    <string name="accessibility_captioning_preference_summary" msgid="8335768472978374255">"Mapendeleo haya ya manukuu hayawezi kutumika katika programu zote za maudhui"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Kitufe cha zana za ufikivu"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"Telezesha vidole viwili juu kutoka upande wa chini"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Shikilia vitufe vya kuongeza sauti"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Gusa skrini mara tatu"</string>
    <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Badilisha njia za mkato za ufikivu"</string>
    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
    <skip />
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Endelea"</string>
    <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Vifaa vya kusaidia kusikia"</string>
    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
    <skip />
    <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Hujaunganisha vifaa vyovyote vya kusikilizia"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Ongeza vifaa vya kusaidia kusikia"</string>
    <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Unganisha visaidizi vya kusikia"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="581652489109350119">"Kwenye skrini inayofuata, gusa visaidizi vyako vya kusikia. Huenda ukahitaji kuoanisha kisaidizi cha sikio la kushoto na cha kulia kando kando.\n\nHakikisha visaidizi vyako vya kusikia vimewashwa na vipo tayari kuoanishwa."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> inatumika"</string>
    <string name="accessibility_hearingaid_left_side_device_summary" msgid="1907302799168261001">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, upande wa kushoto pekee"</string>
    <string name="accessibility_hearingaid_right_side_device_summary" msgid="148257064855054376">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, upande wa kulia pekee"</string>
    <string name="accessibility_hearingaid_left_and_right_side_device_summary" msgid="4268221140368164452">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, kushoto na kulia"</string>
    <string name="accessibility_hearingaid_more_device_summary" msgid="8092641784056942546">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> zaidi ya 1"</string>
    <string name="accessibility_hearing_device_pairing_title" msgid="2701812183769537320">"Unganisha kifaa kipya"</string>
    <string name="accessibility_hearing_device_connected_title" msgid="3785140037249487287">"Vifaa vya kusaidia kusikia"</string>
    <string name="accessibility_hearing_device_saved_title" msgid="7573926212664909296">"Vifaa ulivyohifadhi"</string>
    <string name="accessibility_hearing_device_control" msgid="2661965917013100611">"Vidhibiti vya vifaa vya kusaidia kusikia"</string>
    <string name="accessibility_hearing_device_shortcut_title" msgid="7645100199603031360">"Njia ya mkato ya vifaa vya kusaidia kusikia"</string>
    <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Uoanifu wa vifaa vya kusaidia kusikia"</string>
    <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Huboresha uoanifu na zana za kudukiza umeme katika visaidizi vya kusikia na kupunguza kelele zisizotakiwa"</string>
    <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Kuhusu vifaa vya kusikiliza"</string>
    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
    <skip />
    <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Unganisha vifaa vya kusaidia kusikia"</string>
    <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Unaweza kuunganisha vifaa vya kusikilizia vya ASHA na LE Audio kwenye ukurasa huu. Hakikisha vifaa vyako vya kusikilizia vimewashwa na viko tayari kuoanishwa."</string>
    <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Vifaa vya kusaidia kusikia vinavyopatikana"</string>
    <string name="accessibility_found_all_devices" msgid="7817834722148556520">"Je, huoni vifaa vyako vya kusikia?"</string>
    <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"Angalia vifaa zaidi"</string>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Marekebisho ya sauti"</string>
    <string name="accessibility_toggle_audio_description_preference_title" msgid="8916473886256061220">"Maelezo ya sauti"</string>
    <string name="accessibility_audio_description_summary" msgid="2554789094873781056">"Sikia maelezo ya kinachotendeka katika skrini kwenye filamu na vipindi ambapo hili linawezekana"</string>
    <string name="keywords_audio_description" msgid="6202816411593281252">"maelezo ya sauti, sauti, maelezo, uwezo mdogo wa kuona,"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Kipengele cha njia ya mkato kimewashwa"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Imezimwa"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"Imewashwa"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Imezimwa"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Haifanyi kazi. Gusa ili upate maelezo."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Huduma hii haifanyi kazi vizuri."</string>
    <string name="accessibility_shortcuts_settings_title" msgid="974740249671825145">"Njia za mkato za zana za ufikivu"</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Onyesha katika Mipangilio ya Haraka"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="4210949400493358650">"Nyekundu-kijani"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6392456967103014723">"Nyekundu-kijani"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="2278786218762602022">"Bluu-manjano"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"Kijivu"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="2117727423019598455">"Kijani hafifu, upofu wa kutoona rangi kijani"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="4617032854982040748">"Nyekundu hafifu, upofu wa kutoona rangi nyekundu"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2428218320118180070">"Upofu wa kutoona rangi ya bluu"</string>
    <string name="reduce_bright_colors_preference_title" msgid="2249314004651574997">"Kipunguza mwangaza zaidi"</string>
    <string name="reduce_bright_colors_switch_title" msgid="1751678397884065312">"Punguza mwangaza wa skrini zaidi"</string>
    <string name="reduce_bright_colors_shortcut_title" msgid="495648157059202745">"Njia ya mkato ya kupunguza mwangaza zaidi"</string>
    <string name="reduce_bright_colors_about_title" msgid="503655452544934393">"Kuhusu kipunguza mwangaza zaidi"</string>
    <string name="reduce_bright_colors_preference_intro_text" msgid="3502290826747650566">"Fanya skrini yako iwe na mwangaza hafifu ili iwe rahisi kusoma"</string>
    <string name="reduce_bright_colors_intensity_preference_title" msgid="7455443033955118267">"Ukolezaji"</string>
    <string name="reduce_bright_colors_intensity_start_label" msgid="930387498396426039">"Punguza ung\'aavu"</string>
    <string name="reduce_bright_colors_intensity_end_label" msgid="1422600205484299860">"Ung\'aavu zaidi"</string>
    <string name="reduce_bright_colors_persist_preference_title" msgid="4368829654993343354">"Iendelee kutumika baada ya kuzima na kuwasha kifaa"</string>
    <string name="accessibilty_autoclick_preference_subtitle_short_delay" msgid="2981206111858937724">"{count,plural, =1{Muda mfupi (sekunde {time})}other{Muda mfupi (sekunde {time})}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_medium_delay" msgid="6867395206533459204">"{count,plural, =1{Wastani (sekunde {time})}other{Wastani (sekunde {time})}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_long_delay" msgid="4079139970819335593">"{count,plural, =1{Muda mrefu (sekunde {time})}other{Muda mrefu (sekunde {time})}}"</string>
    <string name="accessibilty_autoclick_delay_unit_second" msgid="5979297390686370567">"{count,plural, =1{Sekunde {time}}other{Sekunde {time}}}"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Mipangilio"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"Imewashwa"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Imezimwa"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Chungulia kwanza"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Chaguo za kawaida"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Lugha"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Ukubwa wa maandishi"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Mtindo wa manukuu"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Chaguo maalum"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Rangi ya mandharinyuma"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Uvulivuli wa Mandhari"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Rangi ya dirisha la manukuu"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Hali ya ung\'avu wa dirisha la manukuu"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Rangi ya maandishi"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Hali ya kuonekana kwa maandishi"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Rangi ya ukingo"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Aina ya kingo"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Makundi ya fonti"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Manukuu yataonekana hivi"</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Chaguomsingi"</string>
    <string name="color_title" msgid="2511586788643787427">"Rangi"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Chaguomsingi"</string>
    <string name="color_none" msgid="3703632796520710651">"Hakuna"</string>
    <string name="color_white" msgid="1896703263492828323">"Nyeupe"</string>
    <string name="color_gray" msgid="8554077329905747877">"Kijivu"</string>
    <string name="color_black" msgid="9006830401670410387">"Nyeusi"</string>
    <string name="color_red" msgid="5210756997426500693">"Nyekundu"</string>
    <string name="color_green" msgid="4400462091250882271">"Kijani"</string>
    <string name="color_blue" msgid="4997784644979140261">"Samawati"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Samawati-Kijani"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Manjano"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Majenta"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"Ungependa kuruhusu <xliff:g id="SERVICE">%1$s</xliff:g> iwe na udhibiti kamili wa kifaa chako?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"<xliff:g id="SERVICE">%1$s</xliff:g> inahitaji:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Kwa sababu programu yako inazuia ombi la ruhusa, Mipangilio haiwezi kuthibitisha majibu yako."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"<xliff:g id="SERVICE">%1$s</xliff:g> inaomba udhibiti kamili wa kifaa hiki. Huduma hii inaweza kusoma skrini na ichukue hatua kwa niaba ya watumiaji walio na matatizo ya kuona au kusikia. Kiwango hiki cha udhibiti hakifai kwa programu nyingi."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"Udhibiti kamili unafaa kwa programu zinazokusaidia kwa mahitaji ya ufikivu, ila si kwa programu nyingi."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Kuangalia na kudhibiti skrini"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"Inaweza kusoma maudhui yote kwenye skrini na kuonyesha maudhui kwenye programu zingine."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Kuangalia na kutekeleza vitendo"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"Inaweza kufuatilia mawasiliano yako na programu au kitambuzi cha maunzi na kuwasiliana na programu zingine kwa niaba yako."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Ruhusu"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Kataa"</string>
    <string name="accessibility_dialog_button_stop" msgid="7584815613743292151">"Zima"</string>
    <string name="accessibility_dialog_button_cancel" msgid="8625997437316659966">"Usizime"</string>
    <string name="disable_service_title" msgid="8178020230162342801">"Ungependa kuzima <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"Hakuna huduma zilizosanidiwa"</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"Hakuna huduma iliyochaguliwa"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"Hakuna maelezo yaliyotolewa."</string>
    <string name="settings_button" msgid="2195468788019730377">"Mipangilio"</string>
    <string name="keywords_reduce_bright_colors" msgid="1683190961013139183">"ung\'avu wa mwangaza, woga wa mwangaza, mandhari meusi, kipandauso, maumivu ya kichwa, hali ya kusoma, hali ya usiku, kupunguza mwangaza, sehemu nyeupe"</string>
    <string name="keywords_accessibility" msgid="8593989878379366798">"kuona, kusikia, vipofu, viziwi, ulemavu wa misuli, umahiri wa kutumia vidole, saidizi, usaidizi, urahisi wa kutumia, urahisi wa kufikia, mkono, usaidizi"</string>
    <string name="keywords_magnification" msgid="3908145308269840862">"Kikuza Dirisha, Kuza, Ukuzaji, Uwezo mdogo wa kuona, Kuza, fanya iwe kubwa"</string>
    <string name="keywords_talkback" msgid="2816435437095102527"></string>
    <string name="keywords_live_caption" msgid="1667203998080567556">"Manukuu, manukuu, manukuu, Nukuu Papo Hapo, tatizo la kusikia, kupoteza uwezo wa kusikia, KIKAPU, kunukuu matamshi, manukuu"</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">"ukubwa wa skrini, skrini kubwa"</string>
    <string name="keywords_bold_text" msgid="6257418169207099589">"Utofautishaji wa juu, uwezo mdogo wa kuona, fonti ya herufi nzito, maneno yenye herufi nzito"</string>
    <string name="keywords_select_to_speak" msgid="2872704811610888719"></string>
    <string name="keywords_color_correction" msgid="8540442886990423681">"badilisha rangi"</string>
    <string name="keywords_color_inversion" msgid="4291058365873221962">"weka skrini iwe nyeusi, weka skrini iwe nyeupe"</string>
    <string name="keywords_contrast" msgid="4668393735398949873">"utofautishaji wa rangi"</string>
    <string name="keywords_accessibility_menu" msgid="4300579436464706608"></string>
    <string name="keywords_switch_access" msgid="5813094504384313402"></string>
    <string name="keywords_auto_click" msgid="6811744211216280998">"ulemavu wa misuli, kipanya, kipanya cha nje, kipanya cha kichwani, kipanya maalum, kiti cha magurudumu, usukani"</string>
    <string name="keywords_hearing_aids" msgid="4657889873249157071">"visaidizi vya kusikia, tatizo la kusikia, kupoteza uwezo wa kusikia, vifaa vinavyosaidia kusikia vinavyopachikwa ndani ya sikio, vifaa vya kukuza sauti, vichakataji sauti, PSAP"</string>
    <string name="keywords_rtt" msgid="2429130928152514402">"tatizo la kusikia, kupoteza uwezo wa kusikia, manukuu, mashine ya chapa, TTY"</string>
    <string name="keywords_voice_access" msgid="7807335263195876454"></string>
    <string name="keywords_3_button_navigation" msgid="436361965016404218">"vitufe vitatu"</string>
    <string name="keywords_touch_and_hold_delay" msgid="7854640156419599912">"umahiri wa kutumia vidole, ulemavu wa misuli, ukongwe, yabisi-kavu, rsi, kiharusi, kutetema, kuathirika kwa mfumo wa neva, kupooza ubongo, kutetemeka, kuumia misuli"</string>
    <string name="keywords_accessibility_timeout" msgid="8903766864902000346">"kuchelewa, umahiri wa kutumia vidole, ukongwe"</string>
    <string name="print_settings" msgid="8519810615863882491">"Kuchapisha"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Imezimwa"</string>
    <string name="print_settings_summary" msgid="1458773840720811915">"{count,plural, =1{Huduma 1 ya kuchapisha imewashwa}other{Huduma # za kuchapisha zimewashwa}}"</string>
    <string name="print_jobs_summary" msgid="7040836482336577323">"{count,plural, =1{Kazi 1 ya kuchapisha}other{Kazi # za kuchapisha}}"</string>
    <string name="print_settings_title" msgid="7680498284751129935">"Huduma za uchapishaji"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"Hakuna huduma zilizosakinishwa"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"Hakuna printa zilizopatikana"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Mipangilio"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Ongeza printa"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"Imewashwa"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Kimezimwa"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Ongeza huduma"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Ongeza printa"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Utafutaji"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Inatafuta printa"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Huduma imezimwa"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Kazi za kuchapisha"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Kazi ya kuchapisha"</string>
    <string name="print_restart" msgid="4424096106141083945">"Anza tena kuchapisha"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Ghairi"</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">"Inaweka mipangilio ya <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"Inachapisha <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"Inaghairi <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Hitilafu kwenye printa <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"Printa imezuiwa <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Kisanduku cha kutafutia kimeonyeshwa"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Kisanduku cha kutafutia kimefichwa"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Maelezo zaidi kuhusu printa hii"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Betri"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Ni nini kimekuwa kikitumia betri"</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">"Imesalia <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> chaji ijae"</string>
    <string name="power_usage_detail_screen_time" msgid="6027274749498485283">"Muda wa kutumia kifaa"</string>
    <string name="power_usage_detail_background_time" msgid="3661437083554322691">"Muda wa programu kuendeshwa chinichini"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Chaji ya betri imepungua"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Iruhusu programu kutumika chini chini"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Ungependa kudhibiti shughuli za chini chini?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"Ikiwa utadhibiti shughuli za chini chini za programu, huenda isifanye kazi vizuri"</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Kwa kuwa programu hii haiboreshi matumizi ya betri, huwezi kuizuia.\n\nIli uizuie, washa kuboresha matumizi ya betri."</string>
    <string name="manager_battery_usage_category_title" msgid="1493303237531629961">"Dhibiti matumizi ya betri"</string>
    <string name="manager_battery_usage_allow_background_usage_title" msgid="6294649996820358852">"Ruhusu matumizi ya chinichini"</string>
    <string name="manager_battery_usage_allow_background_usage_summary" msgid="8021153755201340819">"Washa upate masasisho katika wakati halisi, zima ili uokoe betri"</string>
    <string name="manager_battery_usage_unrestricted_title" msgid="2426486290463258032">"Yasiyodhibitiwa"</string>
    <string name="manager_battery_usage_optimized_title" msgid="8080765739761921817">"Yaliyoboreshwa"</string>
    <string name="manager_battery_usage_restricted_title" msgid="7702863764130323118">"Yanayodhibitiwa"</string>
    <string name="manager_battery_usage_unrestricted_summary" msgid="6819279865465667692">"Ruhusu matumizi ya betri chinichini bila vidhibiti. Huenda yakatumia chaji nyingi ya betri."</string>
    <string name="manager_battery_usage_optimized_summary" msgid="1332545476428039900">"Boresha kulingana na jinsi unavyotumia. Inapendekezwa kwa programu nyingi."</string>
    <string name="manager_battery_usage_restricted_summary" msgid="8324695640704416905">"Dhibiti matumizi ya betri inapotumika chinichini. Huenda programu isifanye kazi ipasavyo. Huenda arifa zikachelewa."</string>
    <string name="manager_battery_usage_footer" msgid="2635906573922553766">"Hatua ya kubadilisha jinsi programu inavyotumia betri yako inaweza kuathiri utendaji wake."</string>
    <string name="manager_battery_usage_footer_limited" msgid="5180776148877306780">"Programu hii inahitaji matumizi ya betri <xliff:g id="STATE">%1$s</xliff:g>."</string>
    <string name="manager_battery_usage_unrestricted_only" msgid="3646162131339418216">"yasiyodhibitiwa"</string>
    <string name="manager_battery_usage_optimized_only" msgid="7121785281913056432">"yaliyoboreshwa"</string>
    <string name="manager_battery_usage_link_a11y" msgid="374918091821438564">"Pata maelezo zaidi kuhusu chaguo za matumizi ya betri"</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Matumizi ya skrini tangu mwisho ilipokuwa imejaa chaji"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Matumizi ya betri"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Maelezo ya historia"</string>
    <string name="advanced_battery_preference_title" msgid="3790901207877260883">"Matumizi ya betri"</string>
    <string name="advanced_battery_preference_summary_with_hours" msgid="954091349133320955">"Angalia matumizi katika saa 24 zilizopita"</string>
    <string name="advanced_battery_preference_summary" msgid="2372763700477268393">"Angalia data ya matumizi tangu ilipojaa chaji mara ya mwisho"</string>
    <string name="battery_details_title" msgid="3289680399291090588">"Programu inavyotumia betri"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Tumia maelezo"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Rekebisha utumiaji wa nishati"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Furushi zilizojumuishwa"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Programu zinatumia chaji kama kawaida"</string>
    <string name="battery_tip_low_battery_title" msgid="4155239078744100997">"Chaji ya betri imepungua"</string>
    <string name="battery_tip_low_battery_summary" msgid="2629633757244297436">"Washa Kiokoa Betri ili uongeze muda wa matumizi ya betri"</string>
    <string name="battery_tip_smart_battery_title" msgid="8925025450214912325">"Boresha muda wa matumizi ya betri"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Washa Kiokoa Betri"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Washa Kiokoa Betri"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"Huenda chaji ikaisha haraka zaidi"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="7705597228709143337">"Kiokoa Betri kimewashwa"</string>
    <string name="battery_saver_link_a11y" msgid="6613079613524512257">"Pata maelezo zaidi kuhusu Kiokoa Betri"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Huenda baadhi ya vipengele vimedhibitiwa"</string>
    <string name="battery_tip_high_usage_title" msgid="9110720762506146697">"Matumizi ya betri ya kiwango cha juu"</string>
    <string name="battery_tip_high_usage_summary" msgid="3938999581403084551">"Angalia programu zinazotumia betri zaidi"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="6258554134146272311">"Hali ya kuchaji imeboreshwa ili kulinda betri yako"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="5107379280241187562">"Ili kuongeza muda wa matumizi ya betri yako, hali ya kuchaji imeboreshwa"</string>
    <string name="battery_tip_limited_temporarily_sec_button_content_description" msgid="5648444926736883551">"Pata maelezo zaidi kuhusu kusitisha kuchaji"</string>
    <string name="battery_tip_limited_temporarily_dialog_resume_charge" msgid="2302295458913832342">"Endelea kuchaji"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Inajumuisha shughuli za chinichini zinazotumia nishati nyingi"</string>
    <string name="battery_tip_restrict_title" msgid="4537101947310626753">"{count,plural, =1{Zuia programu #}other{Zuia programu #}}"</string>
    <string name="battery_tip_restrict_handled_title" msgid="7142074986508706853">"{count,plural, =1{{label} imezuiwa hivi karibuni}other{Programu # zimezuiwa hivi karibuni}}"</string>
    <string name="battery_tip_restrict_summary" msgid="7539469590829235277">"{count,plural, =1{{label} inatumia kiwango cha juu cha betri katika hali ya chinichini}other{Programu # zinatumia kiwango cha juu cha betri katika hali ya chinichini}}"</string>
    <string name="battery_tip_restrict_handled_summary" msgid="3535697154547199190">"{count,plural, =1{Huwezi kutumia programu hii katika hali ya chinichini}other{Huwezi kutumia programu hizi katika hali ya chinichini}}"</string>
    <string name="battery_tip_restrict_app_dialog_title" msgid="1649476357343160240">"{count,plural, =1{Ungependa kuzuia programu?}other{Ungependa kuzuia programu #?}}"</string>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"Ili uokoe betri, zuia <xliff:g id="APP">%1$s</xliff:g> isitumie chaji chinichini. Huenda programu hii isifanye kazi vizuri na huenda arifa zikachelewa."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"Ili uokoe betri, zuia programu hizi zisitumie chaji chinichini. Huenda programu zilizozuiliwa zisifanye kazi vizuri na huenda arifa zikachelewa.\n\nProgramu:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"Ili uokoe betri, zuia programu hizi zisitumie chaji chinichini. Huenda programu zilizozuiliwa zisifanye kazi vizuri na huenda arifa zikachelewa.\n\nProgramu:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Zuia"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Ungependa kuondoa kizuizi?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"Programu hii itatumia chaji chinichini. Hali hii inaweza kufanya chaji ya betri iishe haraka."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Ondoa"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Ghairi"</string>
    <string name="battery_tip_charge_to_full_button" msgid="9172893341338732733">"Batilisha"</string>
    <string name="battery_tip_incompatible_charging_title" msgid="1567827436103364999">"Kagua kifaa cha kuchaji"</string>
    <string name="battery_tip_incompatible_charging_content_description" msgid="355668467640367701">"Pata maelezo zaidi kuhusu adapta ya kuchaji isiyooana"</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Kidhibiti cha Betri"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Dhibiti programu kiotomatiki"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Kidhibiti cha betri kikitambua kuwa programu zinatumia chaji sana, utakuwa na chaguo la kudhibiti programu hizi. Huenda programu zilizodhibitiwa zisifanye kazi vizuri na arifa zikachelewa."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Programu zinazodhibitiwa"</string>
    <string name="restricted_app_summary" msgid="1022307922754893997">"{count,plural, =1{Kudhibiti matumizi ya betri kwa programu #}other{Kudhibiti matumizi ya betri kwa programu #}}"</string>
    <string name="restricted_app_time_summary" msgid="3097721884155913252">"Ilidhibitiwa <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="3495725286882138803">"Programu hizi haziruhusiwi kutumia betri chinichini. Huenda zisifanye kazi ipasavyo na arifa zinaweza kuchelewa."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Tumia Kidhibiti cha Betri"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Tambua wakati programu zinatumia chaji sana"</string>
    <string name="battery_manager_summary" msgid="255708681438809287">"Inatambua wakati programu zinatumia chaji sana"</string>
    <string name="battery_manager_summary_unsupported" msgid="7334173707292807964">"Inatambua wakati programu zinatumia chaji sana"</string>
    <string name="battery_manager_app_restricted" msgid="2583902700677009173">"{count,plural, =1{Programu # imezuiwa}other{Programu # zimezuiwa}}"</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">"Tatizo la kusoma mita ya betri."</string>
    <string name="battery_missing_link_message" msgid="6021565067124898074"></string>
    <string name="battery_missing_link_a11y_message" msgid="3310971406602316323">"Gusa ili upate maelezo zaidi kuhusu hitilafu hii"</string>
    <string name="power_screen" msgid="4596900105850963806">"Skrini"</string>
    <string name="power_cpu" msgid="1820472721627148746">"Kiini cha Kompyuta (CPU)"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Tochi"</string>
    <string name="power_camera" msgid="4778315081581293923">"Kamera"</string>
    <string name="power_gps" msgid="6352380895542498164">"GPS"</string>
    <string name="power_wifi" msgid="4614007837288250325">"Wi-Fi"</string>
    <string name="power_bluetooth" msgid="5085900180846238196">"Bluetooth"</string>
    <string name="power_cell" msgid="7793805106954398186">"Mtandao wa simu"</string>
    <string name="power_phone" msgid="2768396619208561670">"Simu za sauti"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Matumizi ya skrini <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<xliff:g id="PERCENT">%1$s</xliff:g> imetumiwa na <xliff:g id="APP">%2$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="8940140259734182014">"Imetumia <xliff:g id="PERCENT">%1$s</xliff:g> ya chaji ya betri"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Uchanganuzi tangu mara ya mwisho ilipojaa chaji"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Mwisho ilipokuwa imejaa chaji"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"Ikijaa chaji, itadumu kwa takribani"</string>
    <string name="battery_footer_summary" msgid="6753248007004259000">"Muda uliosalia wa matumizi ya betri umekadiriwa na unaweza kubadilika kulingana na matumizi"</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Matumizi ya betri"</string>
    <string name="battery_not_usage" msgid="3851536644733662392">"Haijatumika tangu mara ya mwisho ilipojaa chaji"</string>
    <string name="battery_not_usage_24hr" msgid="8397519536160741248">"Haijatumika katika saa 24 zilizopita"</string>
    <string name="battery_usage_without_time" msgid="1346894834339420538"></string>
    <string name="battery_usage_since_last_full_charge" msgid="3488425008925924769">"tangu ilipojaa chaji mara ya mwisho"</string>
    <string name="battery_usage_system_apps" msgid="8659537819731575299">"Programu za mfumo"</string>
    <string name="battery_usage_uninstalled_apps" msgid="8170405012552803662">"Programu zilizoondolewa"</string>
    <string name="battery_usage_others" msgid="311793281613609986">"Nyingine"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Kadirio la muda uliosalia"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Hadi chaji ijae"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"Kadirio linaweza kubadilika kulingana na matumizi"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Seva ya media"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Uboreshaji wa programu"</string>
    <string name="process_network_tethering" msgid="6822671758152900766">"Inasambaza mtandao"</string>
    <string name="process_removed_apps" msgid="6544406592678476902">"Programu zilizoondolewa"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Kiokoa Betri"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Washa kiotomatiki"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Hakuna ratiba"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Kulingana na ratiba yako"</string>
    <string name="battery_saver_pref_auto_routine_summary" msgid="4739240095966241508">"Kitawashwa kulingana na ratiba yako"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Kulingana na asilimia"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Kiokoa Betri huwashwa kama betri yako inakaribia kuisha kabla ya muda wako wa kawaida wa kuchaji"</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Kitawaka ikifika <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Weka ratiba"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Ongeza muda wa matumizi ya betri"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Zima simu ikipata chaji"</string>
    <string name="battery_saver_sticky_title_percentage" msgid="1178162022087559148">"Zima ikifika <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" msgid="6472610662679038342">"Kiokoa Betri huzima betri inapofika <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">"Washa"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Tumia Kiokoa Betri"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Kujiwasha kiotomatiki"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Kisiwahi kujiwasha"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"chaji ya betri ikiwa <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Asilimia ya chaji ya betri"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Onyesha asilimia ya chaji ya betri kwenye sehemu ya arifa"</string>
    <string name="battery_usage_chart_graph_hint_last_full_charge" msgid="6570336408060566877">"Kiwango cha betri tangu ilipojaa mara ya mwisho"</string>
    <string name="battery_usage_chart_graph_hint" msgid="9182079098173323005">"Kiwango cha betri katika saa 24 zilizopita"</string>
    <string name="battery_app_usage" msgid="8976453608783133770">"Matumizi ya programu tangu betri ilipojaa chaji mara ya mwisho"</string>
    <string name="battery_app_usage_for_past_24" msgid="1234770810563940656">"Matumizi ya programu katika saa 24 zilizopita"</string>
    <string name="battery_system_usage" msgid="1395943945140097585">"Matumizi ya mfumo tangu betri ilipojaa mara ya mwisho"</string>
    <string name="battery_system_usage_for_past_24" msgid="3341520273114616263">"Matumizi ya mfumo katika saa 24 zilizopita"</string>
    <string name="battery_system_usage_for" msgid="3248552137819897140">"Matumizi ya mfumo kwa <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_app_usage_for" msgid="7309909074935858949">"Matumizi ya programu kwa <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_system_usage_since_last_full_charge_to" msgid="4196795733829841971">"Matumizi ya mfumo tangu betri ilipojaa chaji mara ya mwisho hadi <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_app_usage_since_last_full_charge_to" msgid="4339201995118102114">"Matumizi ya programu tangu betri ilipojaa chaji mara ya mwisho hadi <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_usage_total_less_than_one_minute" msgid="1035425863251685509">"Jumla: chini ya dakika moja"</string>
    <string name="battery_usage_background_less_than_one_minute" msgid="3957971442554437909">"Chinichini: chini ya dakika moja"</string>
    <string name="battery_usage_screen_time_less_than_one_minute" msgid="2911989465891679033">"Muda wa kutumia kifaa: chini ya dakika moja"</string>
    <string name="power_usage_time_less_than_one_minute" msgid="8407404329381010144">"Chini ya dakika moja"</string>
    <string name="battery_usage_for_total_time" msgid="8402254046930910905">"Jumla: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_for_background_time" msgid="9109637210617095188">"Chinichini: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_time" msgid="3973865893520804115">"Muda wa kutumia kifaa: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer_empty" msgid="3301144846133808193">"Data ya matumizi ya betri itapatikana saa chache baada ya betri kujaa chaji"</string>
    <string name="battery_usage_chart_label_now" msgid="4598282721949430165">"sasa"</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">"Chati ya matumizi ya betri"</string>
    <string name="daily_battery_usage_chart" msgid="4176059567682992686">"Chati ya matumizi ya betri ya kila siku"</string>
    <string name="hourly_battery_usage_chart" msgid="3098314511076561272">"Chati ya matumizi ya betri ya kila saa"</string>
    <string name="battery_level_percentage" msgid="1433178290838842146">"Asilimia ya chaji ya betri kuanzia <xliff:g id="START_PERCENTAGE">%1$s</xliff:g> hadi <xliff:g id="END_PERCENTAGE">%2$s</xliff:g>"</string>
    <string name="battery_usage_breakdown_title_since_last_full_charge" msgid="435006273323199906">"Matumizi ya betri tangu ilipochajiwa mara ya mwisho"</string>
    <string name="battery_usage_breakdown_title_for_slot" msgid="4823179483667671406">"Matumizi ya betri kuanzia <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="screen_time_category_last_full_charge" msgid="8856908320256057753">"Muda wa kutumia kifaa tangu kilipochajiwa mara ya mwisho"</string>
    <string name="screen_time_category_for_slot" msgid="8287722270554654959">"Muda wa kutumia kifaa kuanzia <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_spinner_view_by_apps" msgid="8769276544072098082">"Angalia kulingana na programu"</string>
    <string name="battery_usage_spinner_view_by_systems" msgid="7904104223212160541">"Angalia kulingana na mifumo"</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">"Kutokana na ukaguzi wa ubora unaofanywa kabla ya usafirishaji, huenda mara ambazo betri imejaa isiwe sufuri unapotumia mara ya kwanza"</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Takwimu za Mchakato"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Takwimu za kitaalamu kuhusu michakato inayoendeshwa"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Kumbukumbu iliyotumika"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"<xliff:g id="USEDRAM">%1$s</xliff:g> kati ya <xliff:g id="TOTALRAM">%2$s</xliff:g> ilitumika katika kipindi cha <xliff:g id="TIMEDURATION">%3$s</xliff:g> zilizopita"</string>
    <string name="process_stats_total_duration_percentage" msgid="4391502694312709148">"<xliff:g id="PERCENT">%1$s</xliff:g> ya RAM ilitumika katika kipindi cha <xliff:g id="TIMEDURATION">%2$s</xliff:g> zilizopita"</string>
    <string name="process_stats_type_background" msgid="4094034441562453522">"Ikifanya kazi chinichini"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"Ikifanya kazi waziwazi"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"Iliyowekwa kwenye akiba"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"Mfumo wa uendeshaji wa Android"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Asili"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Kernel"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Akiba"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"Matumizi ya RAM"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"Matumizi ya RAM (chini chini)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Muda wa kuendesha"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Michakato"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Huduma"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Muda"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Maelezo ya kumbukumbu"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"Saa 3"</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"Saa 6"</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"Saa 12"</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"Siku 1"</string>
    <string name="menu_show_system" msgid="3780310384799907818">"Onyesha mfumo"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Ficha mfumo"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Onyesha asilimia"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"Tumia USS"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Aina ya takwimu"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"Ikifanya kazi chinichini"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"Ikifanya kazi waziwazi"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"Iliyowekwa kwenye akiba"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Kuweka na kupokea data kwa kutamka"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Mipangilio kuweka na kupokea data kwa kutamka"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Tafuta kwa kutamka"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Baobonye la Android"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Mipangilio ya kuweka data kwa kutamka"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Kuweka data kwa kutamka"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Huduma za kuweka data kwa kutamka"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Neno tekelezi na mwingiliano kamilifu"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Huduma rahisi ya kunakili yanayotamkwa"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"Huduma hii ya kuweka data kwa kutamka itakuwa na uwezo wa kutekeleza ufuatiliaji wa hali ya kuwashwa muda wote na kudhibiti programu zinazowashwa kwa sauti kwa niaba yako. Inatoka katika programu ya <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Ungependa kuwasha huduma hii kwa matumizi?"</string>
    <string name="on_device_recognition_settings" msgid="6503160369314598069">"Mipangilio ya utambuzi kwenye kifaa"</string>
    <string name="on_device_recognition_settings_title" msgid="7137599722039096545">"Utambuzi kwenye kifaa"</string>
    <string name="on_device_recognition_settings_summary" msgid="3292736423223499348">"Utambuzi wa matamshi kwenye kifaa"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Mtambo unaopendelewa"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Mipangilio ya Injini"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Kasi na kiwango cha matamshi"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Injini"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Sauti"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Lugha ya Matamshi"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Sakinisha Sauti"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Nenda kwenye programu ya <xliff:g id="TTS_APP_NAME">%s</xliff:g> ili usakinishe sauti"</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"Fungua Programu"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Ghairi"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Weka upya"</string>
    <string name="tts_play" msgid="2945513377250757221">"Cheza"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"VPN"</string>
    <string name="vpn_settings_insecure_single" msgid="9012504179995045195">"Si salama"</string>
    <string name="vpn_settings_single_insecure_multiple_total" msgid="6107225844641301139">"<xliff:g id="VPN_COUNT">%d</xliff:g> si salama"</string>
    <string name="vpn_settings_multiple_insecure_multiple_total" msgid="1706236062478680488">"<xliff:g id="VPN_COUNT">%d</xliff:g> si salama"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Muunganisho unaojirekebisha"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Huboresha muda wa matumizi ya betri na kuboresha utendaji wa kifaa kwa kudhibiti kiotomatiki miunganisho yako ya mtandao"</string>
    <string name="adaptive_connectivity_switch_on" msgid="3653067561620745493">"Imewashwa"</string>
    <string name="adaptive_connectivity_switch_off" msgid="5076172560836115265">"Imezimwa"</string>
    <string name="adaptive_connectivity_main_switch_title" msgid="261045483524512420">"Tumia muunganisho unaojirekebisha"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Hifadhi ya hati tambulishi"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Sakinisha cheti"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Futa stakabadhi"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Ondoa vyeti vyote"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Vitambulisho vinavyoaminika"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Onyesha vyeti vya CA vinavyoaminika"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Kitambulisho cha mtumiaji"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Angalia na urekebishe vitambulisho vilivyohifadhiwa"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Mipangilio Ya Kina"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Kitambulisho hakipatikani kwa mtumiaji huyu"</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Imesakinishwa kwa ajili ya VPN na programu"</string>
    <string name="credential_for_wifi" msgid="2286560570630763556">"Imesakinishwa kwa ajili ya Wi-Fi"</string>
    <string name="credential_for_wifi_in_use" msgid="7276290656840986618">"Imesakinishwa kwa ajili ya Wi-Fi (Inatumika)"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Ungependa kuondoa maudhui yote?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Hifadhi ya stakabadhi imefutwa"</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Hifadhi ya stakabadhi haikuweza kufutwa."</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Zenye idhini ya kufikia maelezo"</string>
    <string name="ca_certificate" msgid="3076484307693855611">"Cheti cha CA"</string>
    <string name="user_certificate" msgid="6897024598058566466">"Cheti cha mtumiaji wa programu na VPN"</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"Cheti cha Wi-Fi"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Data yako haitakuwa ya faragha"</string>
    <string name="ca_certificate_warning_description" msgid="8409850109551028774">"Vyeti vya CA hutumiwa na tovuti, programu na VPN kwa usimbaji fiche. Sakinisha vyeti vya CA kutoka mashirika unayoamini pekee. \n\nUkisakinisha cheti cha CA, mmiliki wa cheti anaweza kufikia data yako, kama vile manenosiri au maelezo ya kadi za mikopo kwenye tovuti unazotembelea au programu unazotumia – hata ikiwa data yako imesimbwa kwa njia fiche."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Usisakinishe"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Sakinisha"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Cheti hakijasakinishwa"</string>
    <string name="request_manage_credentials_title" msgid="596805634568013413">"Ungependa kuruhusu "<b>"<xliff:g id="APP_NAME">^1</xliff:g>"</b>" isakinishe vyeti kwenye kifaa hiki?"</string>
    <string name="request_manage_credentials_description" msgid="8044839857171509619">"Vyeti hivi vitakuthibitisha kwa kushiriki kitambulisho cha kipekee cha kifaa chako na programu na URL zilizo hapa chini"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Usiruhusu"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Ruhusu"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Onyesha zaidi"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"Programu ya kudhibiti vyeti"</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Hamna"</string>
    <string name="certificate_management_app_description" msgid="8507306554200869005">"Vyeti vitakuthibitisha unapotumia programu na URL zilizo hapa chini"</string>
    <string name="uninstall_certs_credential_management_app" msgid="4945883254446077354">"Ondoa vyeti"</string>
    <string name="remove_credential_management_app" msgid="6089291496976812786">"Ondoa programu"</string>
    <string name="remove_credential_management_app_dialog_title" msgid="5713525435104706772">"Ungependa kuondoa programu hii?"</string>
    <string name="remove_credential_management_app_dialog_message" msgid="7739474298063646935">"Programu hii haitadhibiti vyeti, ila itasalia kwenye kifaa chako. Vyeti vyovyote vilivyosakinishwa na programu vitaondolewa."</string>
    <string name="number_of_urls" msgid="1128699121050872188">"{count,plural, =1{URL #}other{URL #}}"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Ishara ya simu ya dharura"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Weka tabia wakati simu ya dharura imepigwa"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Hifadhi nakala"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Hifadhi nakala na uzirejeshe"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Data za kibinafsi"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Hifadhi nakala ya data yangu"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"Hifadhi nakala ya data ya programu, manenosiri ya Wi-Fi na mipangilio mingine kwenye seva za Google"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Akaunti mbadala"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Dhibiti akaunti mbadala"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Jumuisha data ya programu"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Onyesha upya otomatiki"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"Wakati wa kusanidi upya programu, rejesha mipangilio na data ambazo zina nakala rudufu"</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Huduma ya kuhifadhi nakala imezimwa"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Hakuna akaunti ambayo kwa sasa inahifadhi nakala rudufu za data"</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"Ungependa kuacha kuhifadhi nakala za manenosiri, alamisho, mipangilio mingine na data ya programu ya Wi-Fi, na ufute nakala zote kwenye seva za Google?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="2379053988557486162">"Je, ungependa kuacha kuhifadhi nakala ya data ya kifaa (kama vile manenosiri ya Wi-Fi na rekodi ya simu zilizopigwa) na data ya programu (kama vile mipangilio na faili zilizohifadhiwa na programu), na vile vile ufute nakala zote zilizo kwenye seva za mbali?"</string>
    <string name="fullbackup_data_summary" msgid="971587401251601473">"Hifadhi nakala ya data ya kifaa kiotomatiki (kama vile manenosiri ya Wi-Fi na rekodi ya simu zilizopigwa) na data ya programu (kama vile mipangilio na faili zilizohifadhiwa na programu) kwa mbali. \n\nUnapowasha kuhifadhi nakala kiotomatiki, data ya kifaa na programu huhifadhiwa mara kwa mara kiotomatiki kwa mbali. Data ya programu inaweza kuwa data yoyote ambayo programu imehifadhi (kulingana na mipangilio ya msanidi programu), ikiwa ni pamoja na data inayoweza kuwa nyeti kama vile anwani, ujumbe na picha."</string>
    <string name="device_admin_settings_title" msgid="31392408594557070">"Mipangilio ya msimamizi wa kifaa"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"Programu ya msimamizi wa kifaa"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Zima programu ya msimamizi katika kifaa hiki"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Ondoa programu"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Zima na uondoe"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Programu za msimamizi wa kifaa"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"Hakuna programu za msimamizi wa kifaa zinazopatikana"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"Hakuna kipengele cha kutathmini hali ya kuaminika"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Ungependa kuanza kutumia programu ya msimamizi wa kifaa?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Anza kutumia programu ya msimamizi wa kifaa"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Msimamizi wa kifaa"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Ukiwasha programu hii ya msimamizi, itaruhusu <xliff:g id="APP_NAME">%1$s</xliff:g> kutekeleza mambo yafuatayo:"</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"Kifaa hiki kitadhibitiwa na kufuatiliwa na <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"Programu hii ya msimamizi imewashwa na inaruhusu <xliff:g id="APP_NAME">%1$s</xliff:g> kutekeleza mambo yafuatayo:"</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"Ungependa Kuanzisha Msimamizi wa Wasifu?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Ungependa kuruhusu usimamizi?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Ukiendelea, mtumiaji wa programu yako atasimamiwa na msimamizi wako, ambaye anaweza pia kuhifadhi data husika, pamoja na data yako ya binafsi.\n\nMsimamizi wako ana uwezo wa kufuatilia na kudhibiti mipangilio, kufikia programu na data inayohusiana na mtumiaji huyu, ikijumuisha shughuli za mtandao na maelezo ya mahali kilipo kifaa chako."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"Baadhi ya chaguo zimezimwa na msimamizi wako"</string>
    <string name="admin_more_details" msgid="4928985331640193758">"Pata maelezo zaidi"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Kumbukumbu ya arifa"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Historia ya arifa"</string>
    <string name="notification_history_today" msgid="6081829638548808795">"Saa %d zilizopita"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Zilizoahirishwa"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Zilizoondolewa hivi majuzi"</string>
    <string name="notification_history_count" msgid="885305572972482838">"{count,plural, =1{Arifa #}other{Arifa #}}"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Mlio na mtetemo wa simu"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Maelezo ya mtandao"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Kusawazisha kumelemazwa"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Kusawazisha kumelemazwa"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Inasawazisha sasa"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Hitilafu ya usawazishaji."</string>
    <string name="sync_failed" msgid="3806495232114684984">"Usawazishaji haukuwezekana"</string>
    <string name="sync_active" msgid="5787407579281739975">"Usawazishaji amilifu"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Sawazisha"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"Kwa sasa usawazishaji una tatizo. Utarudi baada ya muda mfupi."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Ongeza akaunti"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Wasifu wa kazini bado haupatikani"</string>
    <string name="work_mode_label" msgid="4687734487641548872">"Programu za kazini"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Ondoa wasifu wa kazini"</string>
    <string name="background_data" msgid="321903213000101158">"Data ya maandhari nyuma"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Programu inaweza kusawazisha, kutuma, na kupokea data wakati wowote"</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Lemaza data ya usuli?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"Kulemaza data za usuli huongeza maisha ya betri na hupunguza utumiaji wa data. Programu zingine za kompyuta huenda bado zikatumia muunganisho wa data za usuli."</string>
    <string name="sync_enabled" msgid="5794103781356455043">"Usawazishaji umewashwa"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Usawazishaji umezimwa"</string>
    <string name="sync_error" msgid="846923369794727644">"Hitilafu ya usawazishaji"</string>
    <string name="last_synced" msgid="1527008461298110443">"Ilisawazishwa mwisho <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Inasawazisha sasa..."</string>
    <string name="settings_backup" msgid="5357973563989458049">"Mipangilio ya kuhifadhi nakala rudufu"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Hifadhi nakala za mipangilio yangu"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Sawazisha sasa"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Ghairi usawazishaji"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Gusa ili usawazishe<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g> sasa"</string>
    <string name="sync_gmail" msgid="228561698646018808">"Gmail"</string>
    <string name="sync_calendar" msgid="4603704438090387251">"Kalenda"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Anwani"</string>
    <string name="header_application_sync_settings" msgid="7427706834875419243">"Mipangilio ya kusawazisha programu"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Usawazishaji data"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Badilisha nenosiri"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Mipangilio ya akaunti"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Ondoa akaunti"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Ongeza akaunti"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Je, ungependa kuondoa akaunti?"</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"Mabadiliko haya hayaruhusiwi na msimamizi wako"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Huwezi kusawazisha mwenyewe"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"Kwa sasa usawazishaji wa kipengee hiki umezimwa. Kubadilisha mpangilio huu, washa kwa muda data ya usuli na usawazishaji kiotomatiki."</string>
    <string name="delete" msgid="8330605554706263775">"Futa"</string>
    <string name="select_all" msgid="7898929601615536401">"Chagua zote"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Matumizi ya data"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Wi‑Fi na data ya mtandao wa simu"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Sawazisha kiotomatiki data ya binafsi"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Sawazisha kiotomatiki data ya kazi"</string>
    <string name="account_settings_menu_auto_sync_private" msgid="2315144351530596228">"Sawazisha kiotomatiki data ya faragha"</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"badilisha mzunguko..."</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Siku katika mwezi ya kuweka kipindi kipya cha kutumia data:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"Hakuna programu zilizotumia data wakati wa kipindi hiki."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Ikifanya kazi kutoka mbele"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Ikifanya kazi chinichini"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"Imedhibitiwa"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Ungependa kuzima data ya mtandao wa simu?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Weka kikomo cha data ya simu ya mkononi"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Weka kikomo cha data ya 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Weka kikomo cha data cha 2G-3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Weka kikomo data cha Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"Wi-Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="2951873059375493878">"Etherneti"</string>
    <string name="data_usage_tab_mobile" msgid="952231704205870928">"Simu ya mkononi"</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">"Simu ya mkononi"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"Hakuna"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Data ya mtandao wa simu"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"Data ya 2G-3G"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"Data ya 4G"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Matumizi ya mitandao ya ng\'ambo"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"Inatumika sasa:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"Chini chini:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"Mipangilio ya programu"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Data ya chinichini"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Ruhusu data ya mtandao wa simu itumike chini chini"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Kuzuia data ya usuli kwa programu hii, kwanza weka kikomo cha data ya simu ya mkono."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"Zuia data ya mandhari nyuma?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"Kipengee hiki kinaweza kusababisha programu inayotegemea data ya usuli kuacha kufanya kazi wakati ni mitandao ya simu tu inayopatikana.\n\nUnaweza kupata vidhibiti faafu zaidi vya matumizi ya data katika mipangilio inayopatikana ndani ya programu."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="8599940395497268584">"Hali ya kudhibiti matumizi ya chini chini ya data inawezekana tu wakati umeweka kikomo cha data ya mtandao wa simu."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"Je, data isawazishwe kiotomatiki?"</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"Je, data isisawazishwe kiotomatiki?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"Kuzima kipengele hiki kutaokoa data na matumizi ya betri, lakini utahitajika kusawazisha kila akaunti wewe mwenyewe ili kukusanya taarifa ya hivi karibuni. Na hutapokea arifa masasisho yatakapotokea."</string>
    <string name="data_usage_cycle_editor_title" msgid="2019035830921480941">"Badilisha tarehe ya kipindi cha kutumia data"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Tarehe ya kila mwezi:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Weka"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Weka onyo kwa matumizi ya data"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Weka kikomo cha matumizi ya data"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Kupunguza matumizi ya data"</string>
    <string name="data_usage_sweep_warning" msgid="2072854703184614828"><font size="12">"Onyo la "</font><font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font></string>
    <string name="data_usage_sweep_limit" msgid="6947019190890086284"><font size="12">"Upeo "</font><font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Programu zilizoondolewa"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Watumiaji na programu ziilizoondolewa"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Utumiaji mtandao"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"Mtandao unaopima data"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Jina"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Aina"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Anwani ya seva"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"Kitambulizi cha IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"Ufunguo wa IPSec ulioshirikiwa mapema"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"Cheti cha mtumiaji cha IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"Cheti cha IPSec CA"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"Cheti cha seva cha IPSec"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Onyesha chaguo za kina"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Jina la mtumiaji"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Nenosiri"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Hifadhi maelezo ya akaunti"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(haijatumika)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(usithibitishe seva)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(imepokewa kutoka kwa seva)"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"Maelezo uliyoweka hayatumiki katika hali ya VPN iliyowashwa kila mara"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Ghairi"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Ondoa"</string>
    <string name="vpn_save" msgid="683868204634860888">"Hifadhi"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Unganisha"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Badilisha"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"Badilisha maelezo ya VPN"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Sahau"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Unganisha kwa <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Ungependa kuondoa VPN hii?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Kata muungnisho"</string>
    <string name="vpn_version" msgid="6344167191984400976">"Toleo"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Ondoa VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Ungependa kubadilisha VPN iliyopo?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Ungependa kuweka VPN iliyowashwa kila mara?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Wakati mipangilio hii imewashwa, hutapata muunganisho wa intaneti hadi VPN itakapounganishwa"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"Programu itaondoa VPN iliyopo na hutaweza kuwa na muunganisho wa intaneti hadi VPN itakapounganishwa"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Tayari umeunganisha kwenye VPN ambayo imewashwa kila mara. Ikiwa utaunganisha kwenye programu tofauti, programu hiyo itaondoa VPN iliyopo na kuzima hali ya imewashwa kila mara."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Tayari umeunganisha kwenye VPN. Ikiwa utaunganisha kwenye programu tofauti, programu hiyo itaondoa VPN iliyopo."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Washa"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"<xliff:g id="VPN_NAME">%1$s</xliff:g> imeshindwa kuunganisha"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"Programu hii haitumii VPN iliyo katika hali ya kuwaka kila mara"</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"Ongeza wasifu wa VPN"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Badilisha wasifu"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Futa wasifu"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"VPN Iliyowashwa kila mara"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Hujaongeza VPN zozote"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Usiondoke kwenye muunganisho wa VPN"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Haiwezi kutumia programu hii"</string>
    <string name="vpn_always_on_summary_active" msgid="175877594406330387">"Usizime kamwe"</string>
    <string name="vpn_insecure_summary" msgid="4450920215186742859">"Si salama"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Zuia miunganisho isiyotumia VPN"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"Je, unahitaji muunganisho wa VPN?"</string>
    <string name="vpn_insecure_dialog_subtitle" msgid="1857621742868835300">"Si salama. Sasisha utumie VPN toleo la IKEv2"</string>
    <string name="vpn_start_unsupported" msgid="7139925503292269904">"Imeshindwa kuwasha VPN isiyotumika."</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Chagua wasifu wa VPN ambapo utakuwa umeunganishwa kila mara. Shughuli kwenye mtandao zitaruhusiwa tu wakati umeunganishwa kwenye VPN."</string>
    <string name="vpn_lockdown_none" msgid="455915403560910517">"Hamna"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"Kila mara VPN iliyowashwa inahitaji anwani ya Itifaki Wavuti za seva na DNS."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"Hakuna muunganisho wa mtandao. Tafadhali jaribu tena baadaye."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Ondoa kwenye VPN"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Hamna"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Cheti hakipo. Jaribu kubadilisha wasifu."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"Mfumo"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Mtumiaji"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Zima"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Washa"</string>
    <string name="trusted_credentials_remove_label" msgid="8296330919329489422">"Ondoa"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Kuaminika"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"Ungependa kuwasha cheti cha mfumo cha CA?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"Ungependa kuzima cheti cha mfumo cha CA?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"Ondoa cheti cha CA cha  mtumiaji kabisa?"</string>
    <string name="credential_being_used_by" msgid="3682869943025283499">"Inatumiwa na"</string>
    <string name="credential_contains" msgid="3146519680449595771">"Kipengee ulichoweka kina"</string>
    <string name="one_userkey" msgid="6363426728683951234">"Ufunguo 1 wa mtumiaji"</string>
    <string name="one_usercrt" msgid="2097644070227688983">"Cheti 1 cha mtumiaji"</string>
    <string name="one_cacrt" msgid="982242103604501559">"Cheti 1 cha CA"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"Vyeti vya %d CA"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Maelezo ya kitambulisho"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Imeondoa kitambulisho: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Hakuna kitambulisho cha mtumiaji kilichowekwa"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Kikagua maendelezo"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Kikagua tahajia cha kazini"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Andika nenosiri unalotumia kuhifadhi nakala kamili"</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Andika nenosiri jipya la kuhifadhi nakala kamili"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Andika tena nenosiri lako la kuhifadhi nakala kamili"</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Weka nenosiri mbadala"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Ghairi"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"sasisho za ziada za mfumo"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Huenda mtandao unafuatiliwa"</string>
    <string name="done_button" msgid="6269449526248267">"Nimemaliza"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="1032088078702042090">"{count,plural, =1{Tumia au ondoa cheti}other{Tumia au ondoa vyeti}}"</string>
    <string name="ssl_ca_cert_info_message_device_owner" msgid="7528581447864707873">"{numberOfCertificates,plural, =1{{orgName} amesakinisha mamlaka ya cheti kwenye kifaa chako, huenda hali hii ikaruhusu kuchunguza shughuli za mtandao wa kifaa, ikiwa ni pamoja na barua pepe, programu na tovuti salama.\n\nIli upate maelezo zaidi kuhusu cheti hiki, wasiliana na msimamizi wako.}other{{orgName} amesakinisha mamlaka za cheti kwenye kifaa chako, huenda hali hii ikaruhusu kuchunguza shughuli za mtandao wa kifaa, ikiwa ni pamoja na barua pepe, programu na tovuti salama.\n\nIli upate maelezo zaidi kuhusu vyeti hivi, wasiliana na msimamizi wako.}}"</string>
    <string name="ssl_ca_cert_info_message" msgid="3111724430981667845">"{numberOfCertificates,plural, =1{{orgName} amesakinisha mamlaka ya cheti kwenye wasifu wako wa kazini, huenda hali hii ikaruhusu kuchunguza shughuli za mtandao wa kazini, ikiwa ni pamoja na barua pepe, programu na tovuti salama.\n\nIli upate maelezo zaidi kuhusu cheti hiki, wasiliana na msimamizi wako.}other{{orgName} amesakinisha mamlaka za cheti kwenye wasifu wako wa kazini, huenda hali hii ikaruhusu kuchunguza shughuli za mtandao wa kazini, ikiwa ni pamoja na barua pepe, programu na tovuti salama.\n\nIli upate maelezo zaidi kuhusu vyeti hivi, wasiliana na msimamizi wako.}}"</string>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"Mtu mwingine ana uwezo wa kufuatilia shughuli ya mtandao wako, ikiwa ni pamoja na barua pepe, programu, na tovuti salama. \n\n Kitambulisho cha kuaminika kilichosakinishwa kwenye kifaa chako kinafanikisha hili."</string>
    <string name="ssl_ca_cert_settings_button" msgid="2044927302268394991">"{count,plural, =1{Angalia cheti}other{Angalia vyeti}}"</string>
    <string name="user_settings_title" msgid="6550866465409807877">"Watumiaji wengi"</string>
    <string name="user_list_title" msgid="1387379079186123404">"Watumiaji na wasifu"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Ongeza mtumiaji au wasifu"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Wasifu uliozuiwa"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Mipangilio haijawekwa"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Hajauweka - Wasifu uliozuiwa"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Haujasanidiwa - Wasifu wa kazini"</string>
    <string name="user_admin" msgid="4024553191395768119">"Msimamizi"</string>
    <string name="user_you" msgid="3070562015202859996">"Wewe (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="3328539978480663740">"Huwezi kuongeza watumiaji wengine. Ondoa mtumiaji mmoja ili uongeze mpya."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Wasifu zilizodhibitiwa haziwezi kuongeza akaunti"</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Futa <xliff:g id="USER_NAME">%1$s</xliff:g> kutoka kwenye kifaa hiki"</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Mipangilio ya kufunga skrini"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Ongeza watumiaji skrini ikiwa imefungwa"</string>
    <string name="switch_to_dock_user_when_docked" msgid="2324395443311905635">"Tumia hali ya msimamizi wakati kimepachikwa"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Ungependa kujifuta?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Ungependa kumfuta mtumiaji huyu?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Ungependa kuondoa wasifu?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Ungependa kuondoa wasifu wa kazini?"</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Data na programu zote zitafutwa."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"Ikiwa utaendelea, data na programu zote katika wasifu huu zitafutwa."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Data na programu zote zitafutwa."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Inaongeza mtumiaji mpya..."</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Futa mtumiaji"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Futa"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Data na programu zote katika kipindi hiki zitafutwa."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Ondoa"</string>
    <string name="guest_category_title" msgid="5562663588315329152">"Mgeni (Wewe)"</string>
    <string name="user_category_title" msgid="4368580529662699083">"Watumiaji"</string>
    <string name="other_user_category_title" msgid="7089976887307643217">"Watumiaji wengine"</string>
    <string name="remove_guest_on_exit" msgid="8202972371459611066">"Futa shughuli za mgeni"</string>
    <string name="remove_guest_on_exit_summary" msgid="3969962695703280353">"Futa programu na data yote ya mgeni pale unapofunga matumizi ya wageni"</string>
    <string name="remove_guest_on_exit_dialog_title" msgid="2310442892536079416">"Ungependa kufuta shughuli za mgeni?"</string>
    <string name="remove_guest_on_exit_dialog_message" msgid="8112409834021851883">"Programu na data kutoka kwenye kipindi hiki cha mgeni itafutwa sasa na kila shughuli ya mgeni ya baadaye itafutwa kila mara unapofunga matumizi ya wageni"</string>
    <string name="remove_guest_on_exit_keywords" msgid="4961310523576166193">"futa, mgeni, shughuli, ondoa, data, anayetembelea"</string>
    <string name="enable_guest_calling" msgid="4620657197834392094">"Ruhusu wageni kupiga simu"</string>
    <string name="enable_guest_calling_summary" msgid="4748224917641204782">"Rekodi ya simu zilizopigwa itashirikiwa na mtumiaji mgeni"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Washa kipengele cha SMS na kupiga simu"</string>
    <string name="user_grant_admin" msgid="5942118263054572074">"Mruhusu mtumiaji huyu awe msimamizi"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Futa mtumiaji"</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Ungependa kuwasha SMS na kupiga simu?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"Rekodi ya simu zilizopigwa na SMS zilizopokelewa itashirikiwa na mtumiaji huyu."</string>
    <string name="user_revoke_admin_confirm_title" msgid="3057842401861731863">"Ungependa kuondoa haki za msimamizi?"</string>
    <string name="user_revoke_admin_confirm_message" msgid="9207187319308572958">"Ukimwondolea mtumiaji huyu ruhusa za msimamizi, wewe au msimamizi mwingine anaweza kumrejeshea ruhusa hizo baadaye."</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Maelezo ya dharura"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Maelezo na anwani za <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="open_app_button" msgid="5025229765547191710">"Fungua <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Ruhusu programu na maudhui"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Programu zilizo na vizuizi"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Panua mipangilio ya programu"</string>
    <string name="user_choose_copy_apps_to_another_user" msgid="5914037067347012870">"Chagua programu ili usakinishe"</string>
    <string name="user_copy_apps_menu_title" msgid="5354300105759670300">"Sakinisha programu zinazopatikana"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Malipo ya kielektroniki"</string>
    <string name="nfc_default_payment_settings_title" msgid="2150504446774382261">"Programu chaguomsingi ya kulipa"</string>
    <string name="nfc_default_payment_footer" msgid="978535088340021360">"Ili ulipe ukitumia programu ya kulipa, weka sehemu ya nyuma ya kifaa chako kwenye kisomaji"</string>
    <string name="nfc_more_details" msgid="1700713533074275233">"Pata maelezo zaidi"</string>
    <string name="nfc_default_payment_workapp_confirmation_title" msgid="746921251872504687">"Ungependa kuweka programu ya kazini iwe programu chaguomsingi ya kulipa?"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_title" msgid="1533022606333010329">"Ili ulipe ukitumia programu ya kazini"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_1" msgid="2917430119080702912">"sharti uwashe wasifu wa kazini."</string>
    <string name="nfc_default_payment_workapp_confirmation_message_2" msgid="8161184137833245628">"utatakiwa kuweka PIN, mchoro au nenosiri lako la kazini ikiwa unalo."</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Jinsi yanavyofanya kazi"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Tumia simu yako kulipa katika maduka"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"Chaguomsingi la malipo"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Haijawekwa"</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">"Tumia programu chaguomsingi ya kulipa"</string>
    <string name="nfc_payment_use_default_dialog" msgid="8556328090777785383">"Tumia programu chaguomsingi ya kulipa"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Kila wakati"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"Ila wakati programu nyingine ya malipo imefunguliwa"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"Kwenye kituo cha kielektroniki, lipa ukitumia:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Kulipa katika kituo"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Sanidi programu ya malipo. Kisha elekeza upande wa nyuma wa simu yako kwenye kituo chochote cha malipo chenye alama ya kulipa kwa njia za kielektroniki."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"Nimeelewa"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Zaidi…"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Weka programu chaguomssingi ya kulipa"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Sasisha programu chaguomsingi ya kulipa"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"Kwenye kituo cha kielektroniki, lipa ukitumia <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"Kwenye kituo cha kielektroniki, lipa ukitumia <xliff:g id="APP_0">%1$s</xliff:g>.\n\nHii inachukua nafasi ya <xliff:g id="APP_1">%2$s</xliff:g> kuwa programu yako chaguomsingi ya kulipa."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Weka chaguomsingi"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Sasisha"</string>
    <string name="nfc_work_text" msgid="2496515165821504077">"Kazini"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Vikwazo"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Ondoa vikwazo"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Badilisha PIN"</string>
    <string name="help_label" msgid="2896538416436125883">"Usaidizi na maoni"</string>
    <string name="user_account_title" msgid="6389636876210834864">"Akaunti ya maudhui"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"Kitambulisho cha Picha"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Vitishio vikali"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Pokea arifa kuhusu vitisho vikali kwa maisha na mali"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Vitisho hatari"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Pokea arifa za vitisho vizito kwa maisha na mali"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"Tahadhari za AMBER"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Pokea taarifa kuhusu utekaji watoto nyara"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Rudia"</string>
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Arifa za dharura kupitia vifaa visivyotumia waya"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Kampuni zinazotoa huduma za mitandao"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Majina ya milango ya mtandao"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Upigaji Simu Ulioimarishwa"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"Upigaji simu kupitia 4G"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1067066329756036427">"Tumia huduma za LTE ili uboreshe simu za sauti (inapendekezwa)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="2575004054914178405">"Tumia huduma za 4G ili uboreshe simu za sauti (inapendekezwa)"</string>
    <string name="nr_advanced_calling_title" msgid="6106286679535355939">"Vo5G"</string>
    <string name="nr_advanced_calling_summary" msgid="6926192539172030330">"Tumia 5G kwa simu za sauti"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Tuma anwani kwa mtoa huduma"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Tuma namba za simu za anwani zako ili utoe vipengele vilivyoboreshwa"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Ungependa kutuma anwani kwa <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"Ungependa kutuma anwani kwa mtoa huduma wako?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Nambari za simu za anwani zako zitatumwa kila baada ya kipindi fulani kwa <xliff:g id="CARRIER">%1$s</xliff:g>.<xliff:g id="EMPTY_LINE">

</xliff:g>Maelezo haya hubainisha iwapo anwani zako zinaweza kutumia vipengele fulani, kama vile simu za video au baadhi ya vipengele vya ujumbe."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"Nambari za simu za anwani zako zitatumwa kila baada ya kipindi fulani kwa mtoa huduma wako.<xliff:g id="EMPTY_LINE">

</xliff:g>￼Maelezo haya hubainisha iwapo anwani zako zinaweza kutumia vipengele fulani, kama vile simu za video au baadhi ya vipengele vya ujumbe."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Aina ya mtandao unaoupendelea"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (inapendekezwa)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"Ujumbe wa MMS"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Kutuma na kupokea wakati data ya mtandao wa simu imezimwa"</string>
    <string name="auto_data_switch_title" msgid="5862200603753603464">"Badilisha data ya mtandao wa simu kiotomatiki"</string>
    <string name="auto_data_switch_summary" msgid="1934340931995429057">"Tumia mtandao huu unapopatikana kwa ubora"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"SIM ya Kazi"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Ufikiaji wa programu na maudhui"</string>
    <string name="user_rename" msgid="8735940847878484249">"BADILISHA JINA"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Weka vizuizi vya programu"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Inadhibitiwa na <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Programu hii inaweza kufikia akaunti zako"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"Programu hii inaweza kufikia akaunti yako. Imedhibitiwa na <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="2630656989926554685">"Wi‑Fi na Vifaa vya Mkononi"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Ruhusu marekebisho ya mipangilio ya Wi‑Fi na Vifaa vya Mkononi"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Ruhusu marekebisho ya mipangilio na uoanishaji wa Bluetooth"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Eneo"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Ruhusu programu zitumie maelezo yako ya eneo"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Nyuma"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Endelea"</string>
    <string name="wizard_back_adoptable" msgid="1447814356855134183">"Andaa diski kwa njia nyingine"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_settings_title" msgid="2254609719033946272">"SIM"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Data ya mtandao wa simu haipatikani"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Gusa ili uchague SIM ya data"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Tumia hii kwa simu wakati wote"</string>
    <string name="select_sim_for_data" msgid="2642305487659432499">"Chagua SIM ya data ya mtandao wa simu"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Chagua SIM kwa ajili ya SMS"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Inabadili SIM ya data, hii inaweza kuchukua hadi dakika moja…"</string>
    <string name="select_specific_sim_for_data_title" msgid="5851980301321577985">"Utatumia <xliff:g id="NEW_SIM">%1$s</xliff:g> kwa data ya mtandao wa simu?"</string>
    <string name="select_specific_sim_for_data_msg" msgid="7401698123430573637">"Ukibadilisha uweke <xliff:g id="NEW_SIM">%1$s</xliff:g>, <xliff:g id="OLD_SIM">%2$s</xliff:g> haitatumika tena kwa ajili ya data ya mtandao wa simu."</string>
    <string name="select_specific_sim_for_data_button" msgid="6571935548920603512">"Tumia <xliff:g id="NEW_SIM">%1$s</xliff:g>"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Piga simu ukitumia"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Weka jina la SIM"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"Nafasi ya SIM %1$d"</string>
    <string name="color_orange" msgid="216547825489739010">"Machungwa"</string>
    <string name="color_purple" msgid="6603701972079904843">"Zambarau"</string>
    <string name="sim_status_title" msgid="6188770698037109774">"Hali ya SIM"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"Hali ya SIM (sehemu ya sim %1$d)"</string>
    <string name="sim_signal_strength" msgid="6351052821700294501">"dBm <xliff:g id="DBM">%1$d</xliff:g> asu <xliff:g id="ASU">%2$d</xliff:g>"</string>
    <string name="sim_notification_title" msgid="6839556577405929262">"SIM zako zimebadilika"</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Gusa ili uweke mipangilio"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Uliza kila wakati"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Uteuzi unahitajika"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"Uteuzi wa SIM"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Mipangilio"</string>
    <string name="network_dashboard_title" msgid="788543070557731240">"Mtandao na intaneti"</string>
    <string name="network_dashboard_summary_mobile" msgid="7750924671970583670">"Data ya simu, Wi‑Fi, mtandaopepe"</string>
    <string name="network_dashboard_summary_no_mobile" msgid="4022575916334910790">"Wi-Fi, mtandao pepe"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Vifaa vilivyounganishwa"</string>
    <string name="connected_devices_dashboard_default_summary" msgid="7211769956193710397">"Bluetooth, kuoanisha"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, hali ya kuendesha gari, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, hali ya kuendesha gari"</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="7155882619333726331">"Bluetooth, NFC"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="1175254057213044560">"Bluetooth"</string>
    <string name="connected_devices_dashboard_android_auto_summary" msgid="8179090809275818804">"Bluetooth, Android Auto, hali ya kuendesha gari, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, hali ya kuendesha gari"</string>
    <string name="connected_devices_dashboard_android_auto_no_driving_mode_summary" msgid="6426996842202276640">"Bluetooth, Android Auto, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_no_driving_mode" msgid="1672426693308438634">"Bluetooth, Android Auto"</string>
    <string name="nfc_and_payment_settings_payment_off_nfc_off_summary" msgid="7132040463607801625">"Haipatikani kwa sababu NFC imezimwa"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Ili utumie, sakinisha kwanza programu ya kulipa"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Programu za hivi majuzi, programu chaguomsingi"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Programu zilizo katika wasifu wa kazini haziwezi kufungua arifa."</string>
    <string name="account_dashboard_title" msgid="8228773251948253914">"Manenosiri na akaunti"</string>
    <string name="account_dashboard_default_summary" msgid="7976899924144356939">"Mapendekezo ya kuingia katika akaunti na kujaza kiotomatiki"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Programu chaguomsingi"</string>
    <string name="cloned_apps_dashboard_title" msgid="5542076801222950921">"Programu Zilizonakiliwa"</string>
    <string name="desc_cloned_apps_intro_text" msgid="1369621522882622476">"Tengeneza nakala ya pili ya programu ili uweze kutumia akaunti mbili kwa wakati mmoja."</string>
    <string name="desc_cloneable_app_list_text" msgid="3354586725814708688">"Programu zinazoweza kunakiliwa."</string>
    <string name="cloned_apps_summary" msgid="8805362440770795709">"<xliff:g id="CLONED_APPS_COUNT">%1$s</xliff:g> zimenakiliwa, <xliff:g id="ALLOWED_APPS_COUNT">%2$d</xliff:g> zinapatikana kwa ajili ya kunakiliwa"</string>
    <string name="delete_all_app_clones" msgid="3489053361980624999">"Kufuta nakala zote za Programu"</string>
    <string name="delete_all_app_clones_failure" msgid="6821033414547132335">"Imeshindwa kufuta nakala zote za Programu"</string>
    <string name="cloned_app_creation_summary" msgid="4642627294993918502">"Inaunda…"</string>
    <string name="cloned_app_created_summary" msgid="7277912971544890710">"Imenakiliwa"</string>
    <string name="cloned_app_creation_toast_summary" msgid="3854494347144867870">"Inaunda nakala ya <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="cloned_app_created_toast_summary" msgid="755225403495544163">"Imeunda nakala ya <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Lugha, ishara, saa, hifadhi nakala"</string>
    <string name="languages_setting_summary" msgid="2650807397396180351">"Lugha za mfumo, lugha za programu, mapendeleo ya kimaeneo, matamshi"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, wi-fi, mtandao, muunganisho wa mtandao, intaneti, pasiwaya, data,"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"Arifa ya Wi-Fi, arifa ya wifi"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"matumizi ya data"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Tumia mpangilio wa saa 24"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Fungua ukitumia"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Maombi"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"saa za eneo"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Gumzo kuu, mfumo, arifa, dirisha, kidirisha, onyesho, juu ya programu zingine, droo"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Taa, Mwangaza, Tochi"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"Wi-Fi, wi-fi, geuza, dhibiti"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"mtandao wa simu, rununu, mtoa huduma wa vifaa vya mkononi, isiyotumia waya, data, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"wifi, wi-fi, piga simi, upigaji simu"</string>
    <string name="keywords_display" msgid="874738809280751745">"skrini, skrini ya kugusa"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"punguza mwangaza wa skrini, skrini ya kugusa, betri, ng\'aa"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"punguza mwangaza wa skrini, usiku, kivulivuli, awamu ya usiku, mwangaza, rangi ya skrini, rangi"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"mandhari, weka mapendeleo, badilisha skrini ikufae"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"ukubwa wa maandishi"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"mradi, tuma, Uakisi wa skrini, Kushiriki skrini, uakisi, kushiriki skrini, kutuma skrini"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"nafasi, diski, diski kuu, matumizi ya kifaa"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"matumizi ya nishati, chaji"</string>
    <string name="keywords_battery_usage" msgid="1763573071014260220">"angalia matumizi ya betri, matumizi ya betri, matumizi ya nishati"</string>
    <string name="keywords_battery_saver" msgid="6289682844453234359">"kiokoa betri, kiokoa nishati, kiokoa"</string>
    <string name="keywords_battery_adaptive_preferences" msgid="1774870663426502938">"mapendeleo yanayojirekebisha, betri inayojirekebisha"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"tahajia, kamusi, kagua maendelezo, sahihisha kiotomatiki"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"king\'amuzi, vifaa vya kuingiza sauti, matamshi, ongea, lugha, tumia bila kugusa, utambuzi, la kukera, neno, sauti, historia, vifaa vya sauti, bluetooth"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"kadiria, lugha, chaguomsingi, zungumza, kuzungumza, tts, zana za walio na matatizo ya kuona na kusikia, kisoma skrini, kipofu"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"saa, jeshi"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"weka upya, rejesha, kiwandani"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"futa data yote, futa, rejesha, ondoa, weka mipangilio ya kiwandani"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"printa"</string>
    <string name="keywords_sounds" msgid="187191900698371911">"mlio wa spika, spika, kiwango cha sauti, zima, nyamazisha, sauti, muziki, kugusa, kitetemeshaji, tetema"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"usinisumbue, katiza, kukatiza, katiza"</string>
    <string name="keywords_app" msgid="7983814237980258061">"RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"maeneo ya karibu nawe, mahali, historia, kuripoti, GPS"</string>
    <string name="keywords_accounts" msgid="3013897982630845506">"akaunti, weka akaunti, wasifu wa kazini, weka akaunti, toa, futa"</string>
    <string name="keywords_users" msgid="3497517660077620843">"vikwazo, weka vikwazo, imewekewa vikwazo"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"kusahihisha maandishi, sahihisha, sauti, tetema, otomatiki, lugha, ishara, pendekeza, pendekezo, mandhari, ya kukera, neno, andika, emoji, ya kimataifa"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"weka upya, mapendeleo, chaguomsingi"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"programu, kupakua, programu, mfumo"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"programu, ruhusa, usalama"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"programu, chaguomsingi"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"puuza hali za kuimarisha betri, sinzia, kisitisha programu"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"maridadi, RGB, sRGB, rangi, asili, kawaida"</string>
    <string name="keywords_screen_resolution" msgid="6652125115386722875">"FHD, QHD, ubora, 1080p, 1440p"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"rangi, halijoto, D65, D73, nyeupe, njano, samawati, moto, baridi"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"telezesha kidole ili ufungue, nenosiri, mchoro, PIN"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"kubandika kwenye skirini"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"mashindano kazini, kazi, wasifu"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"wasifu wa kazini, wasifu uliodhibitiwa, unganisha, uunganishaji, kazi, wasifu"</string>
    <string name="keywords_fold_lock_behavior" msgid="6278990772113341581">"kuamka, kulala, kutofunga, kutofunga skrini ukiwa umekunja kifaa, kukunja, kufunga, kunja, funga, skrini imezimwa"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"ishara"</string>
    <string name="keywords_wallet" msgid="3757421969956996972">"Pochi"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"lipa, gusa, malipo"</string>
    <string name="keywords_backup" msgid="707735920706667685">"hifadhi rudufu, hifadhi nakala"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"uso, fungua, thibitisha, ingia katika akaunti"</string>
    <string name="keywords_biometric_unlock" msgid="8569545388717753692">"uso, kufungua, uthibitishaji, kuingia katika akaunti, alama ya kidole, bayometriki"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, min, toleo la prl, imei sv"</string>
    <string name="keywords_sim_status" msgid="4221401945956122228">"mtandao, hali ya mtandao wa simu, hali ya huduma, uthabiti wa mtandao, aina ya mtandao wa simu, kutumia mitandao ya ng\'ambo"</string>
    <string name="keywords_sim_status_esim" msgid="3338719238556853609">"mtandao, hali ya mtandao wa simu, hali ya huduma, uthabiti wa mtandao, aina ya mtandao wa simu, kutumia mitandao ya ng\'ambo, eid"</string>
    <string name="keywords_sim_status_iccid" msgid="4775398796251969759">"mtandao, hali ya mtandao wa simu, hali ya huduma, uthabiti wa mtandao, aina ya mtandao wa simu, kutumia mitandao ya ng\'ambo, iccid"</string>
    <string name="keywords_sim_status_iccid_esim" msgid="4634015619840979184">"mtandao, hali ya mtandao wa simu, hali ya huduma, uthabiti wa mtandao, aina ya mtandao wa simu, kutumia mitandao ya ng\'ambo, iccid, eid"</string>
    <string name="keywords_esim_eid" msgid="8128175058237372457">"eid"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"namba ya ufuatiliaji, toleo la maunzi"</string>
    <string name="keywords_battery_info" msgid="3319796850366687033">"maelezo kuhusu betri, tarehe ilipoundwa, mara ambazo betri imejaa, tarehe ulipotumia mara ya kwanza"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"kiwango cha rekebisho la usalama wa android, toleo la mitambo ya redio, toleo la kiini"</string>
    <string name="keywords_dark_ui_mode" msgid="6373999418195344014">"mandhari, mwangaza, meusi, hali, ung\'aavu wa mwangaza, woga wa mwangaza, punguza mwangaza, punguza mwangaza, hali nyeusi, kipandauso"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"mandhari meusi"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"hitilafu"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Onyesho tulivu, Skrini iliyofungwa"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"arifa za kufunga skrini, arifa"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"uso"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"alama ya kidole, ongeza alama ya kidole"</string>
    <string name="keywords_biometric_settings" msgid="2173605297939326549">"uso, alama ya kidole, weka alama ya kidole"</string>
    <string name="keywords_active_unlock_settings" msgid="4511320720304388889">"kufungua kupitia saa, weka kipengele cha kufungua kupitia saa"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"skrini yenye mwanga hafifu, skrini ya kugusa, betri, mwangaza mahiri, ung\'avu maalum, Ung\'avu otomatiki"</string>
    <string name="keywords_display_adaptive_sleep" msgid="4905300860114643966">"mahiri, punguza mwangaza wa skrini, hali tuli, betri, muda umekwisha, utashi, onyesho, skrini, hakuna shughuli"</string>
    <string name="keywords_auto_rotate" msgid="7288697525101837071">"kamera, mahiri, zungusha skrini kiotomatiki, zungusha skrini kiotomatiki, zungusha, geuza, kuzungusha, wima, mlalo, mkao, wima, mlalo"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"pata toleo jipya, android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"dnd, ratiba, arifa, zuia, nyamazisha, tetema, lala, kazini, angazia, sauti, zima sauti, siku, siku ya kazi, wikiendi, usiku wa siku za wiki, tukio"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"skrini, wakati wa kufunga, muda wa skrini kujizima, kifunga skrini"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"hifadhi, akiba, data, futa, futa data yote, nafasi iliyosalia, nafasi"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"imeunganishwa, kifaa, vipokea sauti vinavyobanwa kichwani, vifaa vya sauti, spika, pasiwaya, unganisha, vifaa vya sauti vya masikioni, muziki, maudhui"</string>
    <string name="keywords_wallpaper" msgid="7332890404629446192">"mandharinyuma, mandhari, gridi, weka mapendeleo, weka mapendeleo"</string>
    <string name="keywords_styles" msgid="3367789885254807447">"aikoni, msisitizo, rangi, skrini ya kwanza, kufunga skrini, njia ya mkato, ukubwa wa saa"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"chaguomsingi, mratibu"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"malipo, chaguomsingi"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"arifa zinazoingia"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"mtandao wa usb, mtandao wa bluetooth, mtandaopepe wa wi-fi"</string>
    <string name="keywords_accessibility_vibration_primary_switch" msgid="730692154347231253">"kuhisi, tetema, mtetemo"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"kuhisi kwa kugusa, tetema, skrini, utambuzi"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"kugusa, kutetema, kupiga simu, utambuzi, mlio"</string>
    <string name="keywords_ramping_ringer_vibration" msgid="3678966746742257366">"kugusa, kutetema, simu, kupiga simu, mlio, polepole"</string>
    <string name="keywords_notification_vibration" msgid="2620799301276142183">"miguso, kutetema, utambuzi, arifa"</string>
    <string name="keywords_alarm_vibration" msgid="4833220371621521817">"miguso, kutetema, utambuzi, kengele"</string>
    <string name="keywords_media_vibration" msgid="723896490102792327">"miguso, kutetema, utambuzi, maudhui"</string>
    <string name="keywords_vibration" msgid="670455132028025952">"miguso, tetema, mtetemo"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"kiokoa betri, inayonata, inayodumu, kiokoa umeme, betri"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"mpangilio, ratiba, kiokoa betri, kuokoa umeme, betri, otomatiki, asilimia"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"volte, upigaji simu ulioimarishwa, upigaji simu kupitia 4g"</string>
    <string name="keywords_nr_advanced_calling" msgid="4157823099610141014">"vo5g, vonr, upigaji simu ulioimarishwa, upigaji simu kupitia mtandao wa 5G"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"ongeza lugha, ongeza lugha"</string>
    <string name="keywords_font_size" msgid="1643198841815006447">"ukubwa wa maandishi, chapa kubwa, fonti kubwa, maandishi makubwa, uwezo mdogo wa kuona, ongeza ukubwa wa maandishi, kikuza fonti, kuongeza ukubwa wa fonti"</string>
    <string name="keywords_always_show_time_info" msgid="1066752498285497595">"onyesho tulivu lisilozimwa kamwe, AOD"</string>
    <string name="keywords_change_nfc_tag_apps_state" msgid="9032287964590554366">"nfc, tagi, kisomaji"</string>
    <string name="keywords_keyboard_vibration" msgid="6485149510591654697">"kibodi, miguso, mtetemo,"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Kiwango cha sauti, mtetemo, Usinisumbue"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Sauti ya maudhui"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Sauti ya maudhui ya kutumwa"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Sauti ya simu"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Sauti ya kengele"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Sauti ya arifa na mlio wa simu"</string>
    <string name="separate_ring_volume_option_title" msgid="2212910223857375951">"Kiwango cha sauti ya mlio"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Sauti ya arifa"</string>
    <string name="ringer_content_description_silent_mode" msgid="1442257660889685934">"Milio ya simu imezimwa"</string>
    <string name="ringer_content_description_vibrate_mode" msgid="5946432791951870480">"Mtetemo wa programu ya milio"</string>
    <string name="notification_volume_content_description_vibrate_mode" msgid="6097212000507408288">"Sauti za arifa zimezimwa, arifa zitatetema"</string>
    <string name="volume_content_description_silent_mode" msgid="377680514551405754">"Umezima sauti ya <xliff:g id="VOLUME_TYPE">%1$s</xliff:g>"</string>
    <string name="notification_volume_disabled_summary" msgid="8679988555852056079">"Haipatikani kwa sababu sauti imezimwa"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Mlio wa simu"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Sauti chaguomsingi ya arifa"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Sauti iliyotolewa na programu"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Sauti chaguomsingi ya arifa"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Sauti chaguomsingi ya kengele"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Iteteme kisha itoe sauti kwa utaratibu"</string>
    <string name="spatial_audio_title" msgid="1775370104206884711">"Sauti Inayojirekebisha Kulingana na Hali"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Sauti za vitufe vya kupiga simu"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Sauti ya kufunga skrini"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Sauti za kuchaji na mtetemo"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Sauti ikiwa imepachikwa"</string>
    <string name="touch_sounds_title" msgid="826964355109667449">"Sauti unapogusa na unapobofya"</string>
    <string name="vibrate_icon_title" msgid="1281100105045362530">"Onyesha aikoni kila wakati ikiwa katika hali ya mtetemo"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Cheza kutumia spika ya kituo"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Sauti zote"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Sauti za maudhui pekee"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Kimya"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Milio"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Mitetemo"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Washa sauti"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Manukuu Papo Hapo"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Wekea maudhui manukuu kiotomatiki"</string>
    <string name="spatial_audio_wired_headphones" msgid="2237355789145828648">"Vipokea sauti vya kichwani vinavyotumia waya"</string>
    <string name="spatial_audio_text" msgid="8201387855375146000">"Sauti kutoka kwenye maudhui yanayooana huwa murua zaidi"</string>
    <string name="spatial_summary_off" msgid="8272678804629774378">"Imezimwa"</string>
    <string name="spatial_summary_on_one" msgid="6239933399496282994">"Imewashwa / <xliff:g id="OUTPUT_DEVICE">%1$s</xliff:g>"</string>
    <string name="spatial_summary_on_two" msgid="4526919818832483883">"Imewashwa / <xliff:g id="OUTPUT_DEVICE_0">%1$s</xliff:g> na <xliff:g id="OUTPUT_DEVICE_1">%2$s</xliff:g>"</string>
    <string name="spatial_audio_footer_title" msgid="8775010547623606088">"Pia, unaweza kuwasha kipengele cha Sauti Inayojirekebisha kwa Vifaa vyenye Bluetooth."</string>
    <string name="spatial_audio_footer_learn_more_text" msgid="3826811708094366301">"Mipangilio ya vifaa vilivyounganishwa"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Hamna}=1{Pana ratiba moja}other{Pana ratiba #}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Usinisumbue"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Pata arifa za watu na programu muhimu pekee"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Punguza usumbufu"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Washa kipengele cha Usinisumbue"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Sauti za kengele na maudhui zinaweza kukatiza"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Ratiba"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Futa kanuni"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Futa"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Badilisha"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Ratiba"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Ratiba"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Ratibu"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Zima simu katika vipindi fulani"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Weka sheria za Usinisumbue"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Ratibu"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Tumia ratiba"</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">"Ruhusu ukatizwe na vipengele vinavyotoa sauti"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Zuia ukatizaji wa maonyesho"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Ruhusu ishara zinazoonekena"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Onyesha chaguo za arifa zilizofichwa"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Wakati umewasha kipengele cha Usinisumbue"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Arifa zisitoe sauti"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Utaona arifa kwenye skrini yako"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"Unapopokea arifa mpya, simu yako haitatoa mlio wala mtetemo."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Arifa zisionekane wala zisitoe sauti"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Hutasikia wala kuona arifa"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="3761837271201073330">"Simu yako haitaonyesha, kutetema au kutoa sauti ukipata arifa mpya au zilizopo. Kumbuka kuwa arifa muhimu kuhusu hali na shughuli za kifaa bado zitaonekana.\n\nUkizima kipengele cha Usinisumbue, utapata arifa ulizokosa kwa kutelezesha kidole chini kutoka sehemu ya juu ya skrini."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="5469078057954463796">"Maalum"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Washa mipangilio maalum"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Ondoa mipangilio maalum"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Arifa zisitoe sauti"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Imefichwa kiasi"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Arifa zisionekane wala zisitoe sauti"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Vikwazo maalum"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Wakati skrini imewashwa"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Wakati skrini imezimwa"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Zima sauti na mtetemo"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Usiwashe skrini"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Usipepese mwangaza"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Usionyeshe arifa kwenye skrini"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Ficha aikoni za sehemu ya arifa upande wa juu kwenye skrini"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Ficha vitone vya arifa kwenye aikoni za programu"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Skrini isiwake arifa zikiingia"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Usionyeshe kwenye orodha kunjuzi"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Kamwe"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Wakati skrini imezimwa"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Wakati skrini imewashwa"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Sauti na mtetemo"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Sauti, mtetemo na baadhi ya ishara za arifa zinazoonekana"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Sauti, mtetemo na ishara za arifa zinazoonekana"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="6403365663466620328">"Haitaficha kamwe arifa zinazohitajika katika hali na shughuli za msingi za kifaa."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Hamna"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"chaguo zingine"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Ongeza"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Washa"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Washa sasa"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Zima sasa"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"Kipengele cha Usinisumbue kitaendelea kutumika hadi <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"Kipengele cha Usinisumbue kitaendelea kutumika hadi utakapokizima"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"Kipengele cha Usinisumbue kimewashwa kiotomatiki na amri (<xliff:g id="RULE_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"Kipengele cha Usinisumbue kimewashwa kiotomatiki na programu ya (<xliff:g id="APP_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"Kipengele cha Usinisumbue kitawaka wakati wa <xliff:g id="RULE_NAMES">%s</xliff:g> kupitia mipangilio maalum."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="8255159194653341835">" "<annotation id="link">"Angalia mipangilio maalum"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Kipaumbele tu"</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">"Imewashwa / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"Imewashwa"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Uliza kila wakati"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Hadi utakapoizima"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{Saa moja}other{Saa #}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{Dakika moja}other{Dakika #}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Imezimwa}=1{Imezimwa / Ratiba 1 inaweza kuwashwa kiotomatiki}other{Zimezimwa / Ratiba # zinaweza kuwashwa kiotomatiki}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Kinachoweza kukatiza kipengele cha Usinisumbue"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Watu"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Programu"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Kengele na mengine"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Ratiba"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Muda wa Mipangilio ya Haraka"</string>
    <string name="zen_settings_general" msgid="2704932194620124153">"Jumla"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Wakati umewasha mipangilio ya Usinisumbue, milio na mitetemo itazimwa, isipokuwa inayotoka kwenye vipengee ambavyo umeruhusu hapo juu."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Mipangilio maalum"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Kagua ratiba"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"Nimeelewa"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Arifa"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Muda"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Ujumbe, matukio na vikumbusho"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"Ukiwasha kipengele cha Usinisumbue, ujumbe, vikumbusho na matukio yatakomeshwa, isipokuwa yanayotoka kwenye vipengee unavyoruhusu hapo juu. Unaweza kubadilisha mipangilio ya ujumbe ili uwaruhusu marafiki, familia na watu wengine wawasiliane nawe."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Nimemaliza"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Mipangilio"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Arifa zisionekane wala zisitoe sauti"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Arifa zisitoe sauti"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"Hutaona wala kusikia arifa. Simu kutoka anwani zenye nyota na wanaorudia kupiga simu zinaruhusiwa."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(Mipangilio ya sasa)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Ungependa kubadilisha mipangilio ya arifa za Usinisumbue?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Sauti za wasifu wa kazini"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Tumia sauti za wasifu wako binafsi"</string>
    <string name="work_use_personal_sounds_summary" msgid="608061627969077231">"Tumia sauti sawa na zile za wasifu wako wa binafsi"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Mlio wa simu ya kazini"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Sauti chaguomsingi ya arifa za kazini"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Sauti chaguomsingi ya kengele za kazini"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Sawa na wasifu binafsi"</string>
    <string name="work_sync_dialog_title" msgid="7810248132303515469">"Ungependa kutumia sauti za wasifu wa binafsi?"</string>
    <string name="work_sync_dialog_yes" msgid="5785488304957707534">"Thibitisha"</string>
    <string name="work_sync_dialog_message" msgid="5066178064994040223">"Wasifu wako wa kazini utatumia sauti sawa na zile za wasifu wako wa binafsi"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Arifa"</string>
    <string name="notification_dashboard_summary" msgid="7530169251902320652">"Historia ya arifa, mazungumzo"</string>
    <string name="conversation_notifs_category" msgid="2549844862379963273">"Mazungumzo"</string>
    <string name="general_notification_header" msgid="3669031068980713359">"Dhibiti"</string>
    <string name="app_notification_field" msgid="3208079070539894909">"Arifa za programu"</string>
    <string name="app_notification_field_summary" msgid="5981393613897713471">"Dhibiti arifa kutoka programu mahususi"</string>
    <string name="advanced_section_header" msgid="6478709678084326738">"Jumla"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Arifa za kazini"</string>
    <string name="profile_section_header_for_advanced_privacy" msgid="8385775428904838579">"Wasifu wa kazini"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Kipaumbele cha arifa inayojirekebisha"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Weka kiotomatiki arifa za kipaumbele cha chini ili Zisitoe sauti"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Nafasi ya arifa zinazojirekebisha"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Panga arifa kiotomatiki kulingana na uhusiano"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Maoni kuhusu arifa zinazojirekebisha"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Onyesha marekebisho yaliyofanywa kwenye arifa na uonyeshe chaguo la kutoa maoni kwenye mfumo"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Badilisha umuhimu wa arifa"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Badilisha mipangilio ya umuhimu iliyobadilishwa na mtumiaji na uruhusu mratibu wa arifa kuweka vipaumbele"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Vitendo na majibu yanayopendekezwa"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Onyesha kiotomatiki vitendo na majibu yanayopendekezwa"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Onyesha arifa za hivi majuzi na zile ulizoahirisha"</string>
    <string name="notification_history" msgid="8663811361243456201">"Historia ya arifa"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Tumia historia ya arifa"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"Umezima historia ya arifa"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Washa historia ya arifa ili uone arifa za hivi majuzi na zile ulizoahirisha"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Hakuna arifa za hivi majuzi"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Arifa za hivi majuzi na zile ulizoahirisha zitaonyeshwa hapa"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"angalia mipangilio ya arifa"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"fungua arifa"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Ruhusu uahirishaji wa arifa"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Kitone cha arifa kwenye aikoni ya programu"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Viputo"</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Viputo"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Yafanye mazungumzo haya yatoe viputo"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Onyesha aikoni inayoelea juu ya programu"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="1794193899792284007">"Ungependa kuwasha viputo vya kifaa hiki?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"Hatua ya kuwasha viputo vya programu hii pia itawasha viputo vya kifaa chako.\n\nHii huathiri programu au mazungumzo mengine yanayoruhusiwa kutoa viputo."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Washa"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Ghairi"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Vimewashwa / Mazungumzo yanaweza kuonekana kama aikoni zinazoelea"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Ruhusu programu zionyeshe viputo"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Baadhi ya mazungumzo yataonekana kama aikoni zinazoelea juu ya programu zingine"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Mazungumzo yote yanaweza kutoa viputo"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Mazungumzo uliyochagua yanaweza kutoa viputo"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Hakuna kinachoweza kutoa viputo"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Mazungumzo"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Mazungumzo yote yanaweza kutoa viputo isipokuwa"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Zima viputo vya mazungumzo haya"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Washa viputo vya mazungumzo haya"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Telezesha kidole kulia ili uondoe menyu na kushoto ili uionyeshe"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Telezesha kidole kushoto ili uondoe menyu na kulia ili uionyeshe"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Ficha arifa zisizo na sauti katika sehemu ya arifa"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Mwangaza umemeteke"</string>
    <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Faragha"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Kuruka skrini iliyofungwa"</string>
    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"Ukishafungua, nenda kwenye skrini uliyotumia mwisho. Arifa hazitaonyeshwa kwenye skrini iliyofungwa. Telezesha kidole chini kutoka juu ili uzione."</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Skrini iliyofungwa, Kufunga skrini, Ruka, Kwepa"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Wakati umefunga wasifu wa kazini"</string>
    <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Onyesha arifa mpya pekee kwenye skrini iliyofungwa"</string>
    <string name="unseen_notifs_lock_screen_summary" msgid="5996722793868021391">"Ondoa kiotomatiki arifa zilizotazamwa awali kwenye skrini iliyofungwa"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Arifa kwenye skrini iliyofungwa"</string>
    <string name="lock_screen_notifs_show_all_summary" msgid="4226586018375762117">"Onyesha mazungumzo, arifa chaguomsingi na zisizo na sauti"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Onyesha mazungumzo, arifa chaguomsingi na zisizo na sauti"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Ficha mazungumzo na arifa zisizo na sauti"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Usionyeshe arifa zozote"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Arifa nyeti"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Onyesha maudhui nyeti wakati skrini imefungwa"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Arifa nyeti za wasifu wa kazini"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Onyesha maudhui nyeti ya wasifu wa kazini wakati skrini imefungwa"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Onyesha maudhui yote ya arifa"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Onyesha tu maudhui nyeti wakati skrini imefunguliwa"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Usionyeshe arifa zozote"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="6326229471276829730">"Ungependa skrini yako iliyofungwa ionyeshe nini?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Skrini iliyofungwa"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Onyesha maudhui yote ya arifa za kazi"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Ficha maudhui nyeti ya kazini"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"Ungependa arifa za wasifu wako zionekane aje wakati kifaa chako kimefungwa?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Arifa za wasifu"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Arifa"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Arifa za programu"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Aina ya arifa"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Utendaji"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Mazungumzo"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Sehemu ya mazungumzo"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Ruhusu programu itumie sehemu ya mazungumzo"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Si mazungumzo"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Ondoa kwenye sehemu ya mazungumzo"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"Haya ni mazungumzo"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Weka kwenye sehemu ya mazungumzo"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"Hakuna mazungumzo yenye kipaumbele"</string>
    <string name="priority_conversation_count" msgid="7291234530844412077">"{count,plural, =1{Mazungumzo # ya kipaumbele}other{Mazungumzo # ya kipaumbele}}"</string>
    <string name="important_conversations" msgid="1233893707189659401">"Mazungumzo yenye kipaumbele"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Onyesha kwenye sehemu ya juu ya mazungumzo na yaonekane kama viputo vinavyoelea"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Onyesha kwenye sehemu ya juu ya mazungumzo"</string>
    <string name="other_conversations" msgid="551178916855139870">"Mazungumzo yasiyopewa kipaumbele"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Mazungumzo uliyofanyia mabadiliko"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Mazungumzo ya hivi majuzi"</string>
    <string name="conversation_settings_clear_recents" msgid="8940398397663307054">"Futa mazungumzo ya hivi majuzi"</string>
    <string name="recent_convos_removed" msgid="2122932798895714203">"Mazungumzo ya hivi majuzi yameondolewa"</string>
    <string name="recent_convo_removed" msgid="8686414146325958281">"Mazungumzo yameondolewa"</string>
    <string name="clear" msgid="5092178335409471100">"Futa"</string>
    <string name="clear_conversation" msgid="5564321180363279096">"Futa gumzo la <xliff:g id="CONVERSATION_NAME">%1$s</xliff:g>"</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Mazungumzo yenye kipaumbele na yaliyobadilishwa yataonekana hapa"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Mazungumzo utakayotia alama kuwa kipaumbele au yale utakayofanyia mabadiliko mengine yoyote, yataonekana hapa. \n\nIli ubadilishe mipangilio ya mazungumzo: \nTelezesha kidole chini kutoka sehemu ya juu ya skrini ili ufungue menyu inayovutwa chini, kisha uguse na ushikilie mazungumzo."</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Punguza"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Zionekane kwenye skrini"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Kimya"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Chaguomsingi"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Ruhusu kukatizwa"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"Ruhusu programu itoe sauti, iteteme au ionyeshe arifa kwenye skrini"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Kipaumbele"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Huonyeshwa kwenye sehemu ya juu ya mazungumzo, huonekana kama kiputo, huonyesha picha ya wasifu kwenye skrini iliyofungwa"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"<xliff:g id="APP_NAME">%1$s</xliff:g> haitumii vipengele vingi vya mazungumzo. Huwezi kuweka mazungumzo kama kipaumbele na mazungumzo hayataonekana kama viputo vinavyoelea."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"Katika eneo la menyu kunjuzi, kunja arifa ziwe katika mstari mmoja"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Hakuna sauti wala mtetemo"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"Hakuna sauti wala mtetemo na huonekana upande wa chini katika sehemu ya mazungumzo"</string>
    <string name="notification_channel_summary_default" msgid="1168420867670390611">"Inaweza kutoa sauti au kutetema kulingana na mipangilio ya kifaa"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Wakati kifaa kimefunguliwa, onyesha arifa kama bango katika sehemu ya juu ya skrini"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"Arifa zote za \"<xliff:g id="APP_NAME">%1$s</xliff:g>\""</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Arifa zote za <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="notifications_sent_daily" msgid="10274479224185437">"{count,plural, =1{Kuhusu arifa # kwa siku}other{Kuhusu arifa # kwa siku}}"</string>
    <string name="notifications_sent_weekly" msgid="7895656213187555346">"{count,plural, =1{Kuhusu arifa # kwa wiki}other{Kuhusu arifa # kwa wiki}}"</string>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Kamwe"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Arifa za kifaa na programu"</string>
    <string name="manage_notification_access_summary" msgid="2907135226478903997">"Dhibiti programu na vifaa vinavyoweza kusoma arifa"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"Ufikiaji kwenye arifa za wasifu wa kazi umezuiwa"</string>
    <string name="notification_assistant_title" msgid="5889201903272393099">"Arifa zilizoboreshwa"</string>
    <string name="notification_assistant_summary" msgid="1957783114840908887">"Pata vitendo, majibu na mambo mengine yanayopendekezwa"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Hamna"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Hakuna programu zilizosakinishwa ambazo zimeomba kufikia arifa."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Ruhusu ifikie arifa"</string>
    <string name="notification_assistant_security_warning_summary" msgid="4846559755787348129">"Kipengele cha Arifa Zilizoboreshwa kilichukua nafasi ya Arifa Zinazojirekebisha za Android katika Android 12. Kipengele hiki kinaonyesha majibu na vitendo vinavyopendekezwa na kupanga arifa zako. \n\nKipengele cha Arifa zilizoboreshwa kinaweza kufikia maudhui ya arifa, ikiwa ni pamoja na taarifa binafsi kama vile majina ya anwani na ujumbe. Kipengele hiki kinaweza pia kuondoa au kujibu arifa, kama vile kujibu simu na kudhibiti kipengele cha Usinisumbue."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Ungependa kuiruhusu <xliff:g id="SERVICE">%1$s</xliff:g> ifikie arifa?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1131986567509818121">"Programu ya <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> itaweza kusoma arifa zote, ikiwa ni pamoja na taarifa binafsi kama vile majina ya anwani, picha na maandishi ya ujumbe unaopokea. Programu hii itaweza pia kuahirisha au kuondoa arifa au kuchukua hatua kwenye vitufe katika arifa, ikiwa ni pamoja na kupokea simu. \n\nHatua hii pia itaipa programu uwezo wa kuwasha au kuzima kipengele cha Usinisumbue na kubadilisha mipangilio inayohusiana."</string>
    <string name="nls_warning_prompt" msgid="1486887096703743841">"Programu ya <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> itaweza:"</string>
    <string name="nls_feature_read_title" msgid="7629713268744220437">"Kusoma arifa zako"</string>
    <string name="nls_feature_read_summary" msgid="1064698238110273593">"Inaweza kusoma arifa zako, ikiwa ni pamoja na taarifa binafsi kama vile anwani, ujumbe na picha."</string>
    <string name="nls_feature_reply_title" msgid="7925455553821362039">"Kujibu ujumbe"</string>
    <string name="nls_feature_reply_summary" msgid="4492543411395565556">"Inaweza kujibu ujumbe na kuchukua hatua kwenye vitufe katika arifa, ikiwa ni pamoja na kuahirisha au kuondoa arifa na kujibu simu."</string>
    <string name="nls_feature_settings_title" msgid="8208164329853194414">"Kubadilisha mipangilio"</string>
    <string name="nls_feature_settings_summary" msgid="3770028705648985689">"Inaweza kuwasha au kuzima kipengele cha Usinisumbue na kubadilisha mipangilio inayohusiana nacho."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Ukizima ufikiaji wa arifa katika <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>, huenda hali hii pia ikazima ufikiaji wa kipengee cha Usinisumbue."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Zima"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Ghairi"</string>
    <string name="notif_type_ongoing" msgid="135675014223627555">"Muda halisi"</string>
    <string name="notif_type_ongoing_summary" msgid="2348867528527573574">"Mawasiliano yanayoendelea katika programu zinazotumika, usogezaji, simu na zaidi"</string>
    <string name="notif_type_conversation" msgid="4383931408641374979">"Mazungumzo"</string>
    <string name="notif_type_conversation_summary" msgid="179142405410217101">"SMS na mawasiliano mengine"</string>
    <string name="notif_type_alerting" msgid="4713073696855718576">"Arifa"</string>
    <string name="notif_type_alerting_summary" msgid="4681068287836313604">"Huenda ikalia au kutetema kulingana na mipangilio"</string>
    <string name="notif_type_silent" msgid="6273951794420331010">"Kimya"</string>
    <string name="notif_type_silent_summary" msgid="7820923063105060844">"Arifa zisizotoa sauti wala kutetema"</string>
    <string name="notification_listener_allowed" msgid="5536962633536318551">"Zinazoruhusiwa"</string>
    <string name="notification_listener_not_allowed" msgid="3352962779597846538">"Zisizoruhusiwa"</string>
    <string name="notif_listener_excluded_app_title" msgid="6679316209330349730">"Angalia programu zote"</string>
    <string name="notif_listener_excluded_app_summary" msgid="2914567678047195396">"Badilisha mipangilio ya kila programu inayotuma arifa"</string>
    <string name="notif_listener_excluded_app_screen_title" msgid="8636196723227432994">"Programu zinazoonyeshwa kwenye kifaa"</string>
    <string name="notif_listener_not_migrated" msgid="6265206376374278226">"Programu hii haitumii mipangilio iliyoboreshwa"</string>
    <string name="notif_listener_more_settings" msgid="1348409392307208921">"Mipangilio zaidi"</string>
    <string name="notif_listener_more_settings_desc" msgid="7995492074281663658">"Mipangilio zaidi inapatikana ndani ya programu hii"</string>
    <string name="notification_polite_title" msgid="6121016426991791557">"Kupungua kwa shughuli ya arifa"</string>
    <string name="notification_polite_all_apps" msgid="1118651561594250059">"Tumia hali ya kupungua kwa shughuli kwenye programu zote"</string>
    <string name="notification_polite_all_apps_summary" msgid="540268373207498126">"Punguza polepole sauti ya arifa unapopata arifa nyingi zinazofuatana kutoka kwa programu moja"</string>
    <string name="notification_polite_conversations" msgid="8197695136727245741">"Tumia hali ya kupungua kwa shughuli katika mazungumzo"</string>
    <string name="notification_polite_conversations_summary" msgid="2677141765664359994">"Punguza polepole sauti ya arifa unapopokea ujumbe mwingi kutoka kwa gumzo moja ndani ya kipindi kifupi cha muda"</string>
    <string name="notification_polite_disabled" msgid="1378078021594282842">"Usitumie arifa ya hali ya kupungua kwa shughuli"</string>
    <string name="notification_polite_disabled_summary" msgid="1145341260283746936">"Usipunguze kamwe sauti ya arifa, bila kujali idadi ya arifa zinazofuatana kutoka kwa programu moja"</string>
    <string name="notification_polite_vibrate_unlocked" msgid="6142573851761357903">"Iteteme inapofunguliwa"</string>
    <string name="notification_polite_vibrate_unlocked_summary" msgid="1678472892282874459">"Iteteme tu wakati skrini imefunguliwa"</string>
    <string name="notification_polite_work" msgid="8823596456640216391">"Tumia kwenye wasifu wa kazini"</string>
    <string name="notification_polite_work_summary" msgid="8260947839104352075">"Tumia mipangilio ya kupungua kwa shughuli ya arifa ya wasifu wa binafsi kwenye wasifu wa kazini"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"Huduma za kisaidizi cha Uhalisia Pepe"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Hakuna programu zilizosakinishwa ambazo zinaweza kutekeleza huduma za kisaidizi cha Uhalisia Pepe."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"Ungependa kuruhusu huduma za Uhalisia Pepe katika <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"<xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> kitaweza kutekeleza unapotumia programu katika hali ya uhalisia pepe."</string>
    <string name="display_vr_pref_title" msgid="4850474436291113569">"Kifaa kikiwa Hali ya Uhalisia Pepe"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Punguza ukungu (inapendekezwa)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Punguza mmemeteko"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Picha ndani ya picha"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Hujasakinisha programu yoyote inayoweza kutumia kipengele cha Picha ndani ya picha"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"pip picha ndani"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Picha ndani ya picha"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Ruhusu picha ndani ya picha"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Ruhusu programu hii iunde kidirisha cha picha ndani ya picha wakati programu imefunguka au baada ya kuifunga (kwa mfano, ili uendelee kutazama video). Kidirisha hiki kitaonekana juu ya programu zingine unazotumia."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Programu za kazi na za binafsi pamoja"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Imeunganishwa"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Hazijaunganishwa"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"Hakuna programu zilizounganishwa"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"sehemu ya wasifu programu zilizounganishwa programu za kazini na binafsi"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Umeunganisha"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Unganisha programu hizi"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Programu zilizounganishwa hushiriki ruhusa na kila moja inaweza kufikia data ya nyingine."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Unganisha tu programu ikiwa unaamini kuwa hazishiriki data binafsi na msimamizi wako wa TEHAMA."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Unaweza kutenganisha programu wakati wowote katika mipangilio ya faragha ya kifaa chako."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Ungependa kuamini <xliff:g id="NAME">%1$s</xliff:g> ya kazini na data yako ya binafsi?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Unganisha tu programu ikiwa unaamini kuwa hazishiriki data binafsi na msimamizi wako wa TEHAMA."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"Data ya programu"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Programu hii inaweza kufikia data katika programu yako ya binafsi ya <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Ruhusa"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Programu hii inaweza kutumia ruhusa za binafsi za programu yako ya <xliff:g id="NAME">%1$s</xliff:g>, kama vile ruhusa ya kufikia mahali, hifadhi au anwani."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Hakuna programu zilizounganishwa"</string>
    <string name="interact_across_profiles_number_of_connected_apps" msgid="4000424798291479207">"{count,plural, =1{Programu # imeunganishwa}other{Programu # zimeunganishwa}}"</string>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Ili uunganishe programu hizi, sakinisha <xliff:g id="NAME">%1$s</xliff:g> katika wasifu wako wa kazini"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Ili uunganishe programu hizi, sakinisha <xliff:g id="NAME">%1$s</xliff:g> katika wasifu wako wa binafsi"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Gusa ili upate programu"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Kufikia kipengele cha Usinisumbue"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Ruhusu kipengele cha Usinisumbue"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Hakuna programu zilizosakinishwa ambazo zimeomba kufikia kipengele cha Usinisumbue"</string>
    <string name="app_notifications_off_desc" msgid="2484843759466874201">"Hujaruhusu arifa kutoka kwenye programu hii"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"Kutokana na ombi lako, Android inazuia aina hizi za arifa ili zisionekane kwenye kifaa hiki"</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"Kutokana na ombi lako, Android inazuia kikundi hiki cha arifa ili zisionekane kwenye kifaa hiki"</string>
    <string name="app_notifications_not_send_desc" msgid="5683060986735070528">"Programu hii haitumi arifa"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Aina"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Nyingine"</string>
    <string name="no_channels" msgid="4716199078612071915">"Programu hii haijachapisha arifa zozote"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Mipangilio ya ziada katika programu"</string>
    <string name="show_unused_channels" msgid="2754356124204058828">"Onyesha chaneli ambazo hazitumiwi"</string>
    <string name="hide_unused_channels" msgid="9049958190570733200">"Ficha chaneli ambazo hazitumiwi"</string>
    <string name="deleted_channels" msgid="8489800381509312964">"{count,plural, =1{Aina # imefutwa}other{Aina # zimefutwa}}"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Zuia zote"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Usionyeshe arifa hizi kamwe"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Onyesha arifa"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Usiwahi kuonyesha arifa kwenye vifaa vya kando au katika kivuli"</string>
    <string name="app_notification_fsi_permission_title" msgid="5424116606034705020">"Ruhusu arifa kwenye skrini nzima"</string>
    <string name="app_notification_fsi_permission_summary" msgid="7673487977631068039">"Ruhusu arifa zionekane kwenye skrini nzima wakati umefunga kifaa"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Ruhusu kitone cha arifa"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Onyesha kitone cha arifa"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Hali ya \'Usinisumbue\' isizingatiwe"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Ruhusu arifa hizi ziendelee kuingia wakati umewasha kipengele cha Usinisumbue"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Skrini iliyofungwa"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Nimemaliza"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Mwangaza umemeteke"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Mtetemo"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Mlio"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Kipaumbele"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Jina la ratiba"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Weka jina la ratiba"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"Jina la ratiba tayari linatumika"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Ongeza zingine"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Ongeza ratiba ya tukio"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Ongeza ratiba ya wakati"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Chagua aina ya ratiba"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Je, ungependa kuifuta sheria ya \"<xliff:g id="RULE">%1$s</xliff:g>\"?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Futa"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"Huwezi kubadilisha mipangilio hii sasa hivi. Programu (<xliff:g id="APP_NAME">%1$s</xliff:g>) imewasha kiotomatiki hali ya Usinisumbue yenye shughuli maalum."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"Huwezi kubadilisha mipangilio hii sasa hivi. Programu imewasha kiotomatiki hali ya Usinisumbue yenye shughuli maalum."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"Huwezi kubadilisha mipangilio hii sasa hivi. Mtu aliwasha Hali ya Usinisumbue yenye shughuli maalum."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Saa"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Tukio"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Wakati wa matukio ya"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"Kalenda yoyote"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"Ambapo jibu ni"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"Ndiyo, Labda au Jibu halijatolewa"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"Ndiyo au Labda"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Ndiyo"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Sheria haikupatikana."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"Washa. <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">"Siku"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Hamna"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"Kengele inaweza kulia kabla kipindi kilichoteuliwa kuisha"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Ratiba huzimwa kengele inapolia"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Sifa za Usinisumbue"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Tumia mipangilio chaguomsingi"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Weka mipangilio maalum ya ratiba hii"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"Hali ya ‘<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">"Mazungumzo"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"Mazungumzo yote"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Mazungumzo yenye kipaumbele"</string>
    <string name="zen_mode_from_important_conversations_second" msgid="7588299891972136599">"mazungumzo ya kipaumbele"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Hamna"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Hamna}=1{Mazungumzo 1}other{Mazungumzo #}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Anayeweza kukatiza"</string>
    <string name="zen_mode_people_footer" msgid="7710707353004137431">"Hata kama programu za kutuma ujumbe au kupiga simu hazitaweza kukuarifu, watu unaowachagua hapa bado wanaweza kukupata kupitia programu hizo"</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Simu"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Simu zilizopigwa"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"simu"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Simu zinazoweza kukatiza"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"Ili uhakikishe kuwa simu zinazoruhusiwa zinatoa sauti, hakikisha umeweka mipangilio ya kifaa kulia"</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"Kwa hali ya ‘<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>’, simu zinazoingia zimezuiwa. Unaweza kubadilisha mipangilio ili uwaruhusu marafiki, familia na watu wengine wawasiliane nawe."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Anwani zenye nyota"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Hamna}=1{{contact_1}}=2{{contact_1} na {contact_2}}=3{{contact_1}, {contact_2} na {contact_3}}other{{contact_1}, {contact_2} na zingine #}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Hakuna jina)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Ujumbe"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"ujumbe"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Ujumbe"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Ujumbe unaoweza kukatiza"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"Ili uhakikishe kuwa ujumbe unaoruhusiwa unatoa sauti, hakikisha umeweka mipangilio ya kifaa kulia"</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"Katika hali ya ‘<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>’ ujumbe unaoingia umezuiwa. Unaweza kubadilisha mipangilio ili uwaruhusu marafiki, familia na watu wengine wawasiliane nawe."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Ujumbe wote unaweza kukufikia"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Simu zote zinaweza kukufikia"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Hamna}=1{Anwani moja}other{Anwani #}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Mtu yeyote"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Anwani"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Anwani zenye nyota"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Hamna"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Hamna"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Kengele"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"Kutoka vipima muda, kengele, mifumo ya usalama na programu zingine"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"kengele"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Kengele"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Sauti za maudhui"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Sauti kutoka kwenye video, michezo na maudhui mengine"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"maudhui"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Maudhui"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Sauti inapoguswa"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Sauti kutoka kwa kibodi na vitufe vingine"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"sauti inapoguswa"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Sauti inapoguswa"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Vikumbusho"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"Kutoka majukumu na vikumbusho"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"vikumbusho"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Vikumbusho"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Matukio ya kalenda"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"Kutoka matukio yajayo ya kalenda"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"matukio"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"Matukio"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Ruhusu programu zibatilishe hali"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Programu zinazoweza kukatiza"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Chagua programu zaidi"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Hujachagua programu yoyote"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Hakuna programu zinazoweza kukatiza"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Weka programu"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Arifa zote"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Baadhi ya arifa"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Watu uliochagua bado wanaweza kuwasiliana nawe, hata usiporuhusu programu zikatize"</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Hakuna programu zinazoweza kukatiza}=1{{app_1} inaweza kukatiza}=2{{app_1} na {app_2} zinaweza kukatiza}=3{{app_1}, {app_2} na {app_3} zinaweza kukatiza}other{{app_1}, {app_2} na zingine # zinaweza kukatiza}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Programu"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Arifa zinazoweza kukatiza"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Ruhusu arifa zote"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Hakuna kinachoweza kukatiza}=1{{sound_category_1} inaweza kukatiza}=2{{sound_category_1} na {sound_category_2} zinaweza kukatiza}=3{{sound_category_1}, {sound_category_2} na{sound_category_3} zinaweza kukatiza}other{{sound_category_1}, {sound_category_2} na nyingine # zinaweza kukatiza}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Hakuna kinachoweza kukatiza"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Hakuna mtu anayeweza kukatiza"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Baadhi ya watu wanaweza kukatiza"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Watu wote wanaweza kukatiza"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Wanaorudia kupiga simu"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Ruhusu wanaorudia kupiga simu"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"mtu yeyote"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"anwani"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"anwani zenye nyota"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"wanaorudia kupiga simu"</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> na <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"Mtu yule yule akipiga simu mara ya pili katika kipindi cha dakika <xliff:g id="MINUTES">%d</xliff:g>"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Wakati wa kuanza"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Wakati wa kumalizika"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> siku inayofuata"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Badilisha utumie kengele pekee kwa muda usiojulikana"</string>
    <string name="zen_mode_summary_alarms_only_by_minute" msgid="6673649005494939311">"{count,plural, =1{Badilisha utumie kengele pekee kwa dakika moja hadi {time}}other{Badilisha utumie kengele pekee kwa dakika # (hadi {time})}}"</string>
    <string name="zen_mode_summary_alarms_only_by_hour" msgid="7400910210950788163">"{count,plural, =1{Badilisha utumie kengele pekee kwa saa moja hadi {time}}other{Badilisha utumie kengele pekee kwa saa # hadi {time}}}"</string>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Badilisha utumie kengele pekee hadi <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Badilisha utumie hali ya katiza wakati wote"</string>
    <string name="warning_button_text" msgid="1274234338874005639">"Onyo"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Funga"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Tuma maoni kuhusu kifaa hiki"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Weka PIN ya msimamizi"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"Imewashwa"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Imezimwa"</string>
    <string name="nfc_setting_on" msgid="7701896496026725772">"Kimewashwa"</string>
    <string name="nfc_setting_off" msgid="7142103438532732309">"Kimezimwa"</string>
    <string name="screen_pinning_switch_on_text" msgid="6971386830247542552">"Kimewashwa"</string>
    <string name="screen_pinning_switch_off_text" msgid="5032105155623003875">"Kimezimwa"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Kubandika programu"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"Huduma ya kubandika programu hukuruhusu kuendelea kuonyesha programu ya sasa hadi utakapoibandua. Kipengele hiki kinaweza kutumika, kwa mfano, kumruhusu rafiki unayemwamini kucheza mchezo mahususi."</string>
    <string name="screen_pinning_description" msgid="5822120806426139396">"Ukibandika programu, inaweza kufungua programu zingine na huenda ikafikia data binafsi. \n\nIli utumie kipengele cha kubandika programu: 	\n{0,number,integer}. Washa kipengele cha kubandika programu 	\n{1,number,integer}. Fungua Muhtasari 	\n{2,number,integer}. Gusa aikoni ya programu kwenye sehemu ya juu ya skrini, kisha uguse Bandika"</string>
    <string name="screen_pinning_guest_user_description" msgid="2307270321127139579">"Ukibandika programu, inaweza kufungua programu zingine na huenda ikafikia data binafsi. \n\nKama ungependa kushiriki kifaa chako na mtu mwingine kwa njia salama, jaribu kutumia wasifu wa mgeni badala yake. \n\nIli utumie kipengele cha kubandika programu: 	\n{0,number,integer}. Washa kipengele cha kubandika programu 	\n{1,number,integer}. Fungua Muhtasari 	\n{2,number,integer}. Gusa aikoni ya programu kwenye sehemu ya juu ya skrini, kisha uguse Bandika"</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Wakati programu imebandikwa: \n\n• Data binafsi inaweza kufikiwa \n (kama vile maudhui ya barua pepe na anwani) \n•Programu iliyobandikwa inaweza kufungua programu zingine \n\nTumia huduma ya kubandika programu na watu unaowaamini pekee."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Omba mchoro wa kufungua kabla hujabandua"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Itisha PIN kabla hujabandua"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Omba nenosiri kabla hujabandua"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Funga kifaa wakati wa kubandua"</string>
    <string name="confirm_sim_deletion_title" msgid="7262127071183428893">"Thibitisha kuwa ungependa kufuta eSIM yako"</string>
    <string name="confirm_sim_deletion_description" msgid="4439657901673639063">"Thibitisha kuwa ni wewe kabla ya kufuta eSIM"</string>
    <string name="memtag_title" msgid="5096176296797727201">"Toleo la Beta la Ulinzi wa kumbukumbu wa hali ya juu."</string>
    <string name="memtag_toggle" msgid="8695028758462939212">"Ulinzi wa kumbukumbu wa hali ya juu."</string>
    <string name="memtag_intro" msgid="579408691329568953">"Kipengele hiki cha beta hukusaidia kulinda kifaa chako dhidi ya hitilafu zinazoweza kuhatarisha usalama wako."</string>
    <string name="memtag_on" msgid="824938319141503923">"Umewasha"</string>
    <string name="memtag_off" msgid="4835589640091709019">"Umezima"</string>
    <string name="memtag_on_pending" msgid="1592053425431532361">"Umewashwa baada ya kuzima mfumo kisha kuuwasha tena"</string>
    <string name="memtag_off_pending" msgid="1543177181383593726">"Umezimwa baada ya kuzima na kuwashwa tena"</string>
    <string name="memtag_force_off" msgid="1143468955988138470">"Haipatikani kwa sasa kwenye kifaa chako"</string>
    <string name="memtag_force_on" msgid="3254349938627883664">"Usizime kamwe kwenye kifaa chako"</string>
    <string name="memtag_footer" msgid="8480784485124271376">"Itabidi uzime kisha uwashe kifaa chako ili uwashe au uzime Ulinzi wa kumbukumbu wa hali ya juu. Wakati umewashwa, unaweza kuona utendaji wa kifaa kuwa wa polepole."</string>
    <string name="memtag_reboot_title" msgid="1413471876903578769">"Ungependa kuzima kisha uwashe kifaa?"</string>
    <string name="memtag_reboot_message_on" msgid="3270256606602439418">"Utahitaji kuzima kisha uwashe kifaa chako ili uwashe Ulinzi wa kumbukumbu wa hali ya juu."</string>
    <string name="memtag_reboot_message_off" msgid="2567062468140476451">"Utahitaji kuzima kisha uwashe kifaa chako ili uzime Ulinzi wa kumbukumbu wa hali ya juu."</string>
    <string name="memtag_reboot_yes" msgid="5788896350697141429">"Zima kisha uwashe"</string>
    <string name="memtag_reboot_no" msgid="2860671356184849330">"Si sasa"</string>
    <string name="memtag_learn_more" msgid="1596145970669119776">"Pata maelezo zaidi kuhusu Ulinzi wa kumbukumbu wa hali ya juu."</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"Wasifu huu wa kazini unasimamiwa na:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Inasimamiwa na <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Fungua moja kwa moja"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Fungua viungo vinavyoweza kutumika"</string>
    <string name="app_launch_top_intro_message" msgid="137370923637482459">"Ruhusu viungo vya wavuti vifunguke katika programu hii"</string>
    <string name="app_launch_links_category" msgid="2380467163878760037">"Viungo vya kufunguka katika programu hii"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Viungo vinavyoweza kutumika"</string>
    <string name="app_launch_other_defaults_title" msgid="5674385877838735586">"Mapendeleo mengine chaguomsingi"</string>
    <string name="app_launch_add_link" msgid="8622558044530305811">"Weka kiungo"</string>
    <string name="app_launch_footer" msgid="4521865035105622557">"Programu inaweza kuthibitisha viungo ili vifunguke kiotomatiki katika programu."</string>
    <string name="app_launch_verified_links_title" msgid="621908751569155356">"{count,plural, =1{Kiungo # kilichothibitishwa}other{Viungo # vilivyothibitishwa}}"</string>
    <string name="app_launch_verified_links_message" msgid="190871133877476176">"{count,plural, =1{Kiungo hiki kimethibitishwa na kinafunguka kiotomatiki katika programu hii.}other{Viungo hivi vimethibitishwa na vinafunguka kiotomatiki katika programu hii.}}"</string>
    <string name="app_launch_dialog_ok" msgid="1446157681861409861">"Sawa"</string>
    <string name="app_launch_verified_links_info_description" msgid="7514750232467132117">"Onyesha orodha ya viungo vilivyothibitishwa"</string>
    <string name="app_launch_checking_links_title" msgid="6119228853554114201">"Inatafuta viungo vingine vinavyoweza kutumika…"</string>
    <string name="app_launch_dialog_cancel" msgid="6961071841814898663">"Ghairi"</string>
    <string name="app_launch_supported_links_title" msgid="2457931321701095763">"{count,plural, =1{Kiungo # kinachoweza kutumika}other{Viungo # vinavyoweza kutumika}}"</string>
    <string name="app_launch_supported_links_add" msgid="3271247750388016131">"Weka"</string>
    <string name="app_launch_supported_links_subtext" msgid="4268004019469184113">"Hufunguka katika <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"<xliff:g id="SIZE">%1$s</xliff:g> zimetumika katika <xliff:g id="STORAGE_TYPE">%2$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="979243131665635278">"hifadhi ya mfumo"</string>
    <string name="storage_type_external" msgid="125078274000280821">"hifadhi ya nje"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"<xliff:g id="SIZE">%1$s</xliff:g> tangu <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="2591194906751432725">"Hifadhi iliyotumika"</string>
    <string name="change" msgid="273206077375322595">"Badilisha"</string>
    <string name="change_storage" msgid="8773820275624113401">"Badilisha hifadhi"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Arifa"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"Imewashwa"</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">"Zima"</string>
    <string name="notifications_categories_off" msgid="7712037485557237328">"{count,plural, =1{Aina # imezimwa}other{Aina # zimezimwa}}"</string>
    <string name="runtime_permissions_additional_count" msgid="6071909675951786523">"{count,plural, =1{Ruhusa # ya ziada}other{Ruhusa # za ziada}}"</string>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"Hakuna ruhusa zilizotolewa"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Hakuna ruhusa zilizoombwa"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Dhibiti uwezo wa programu kufikia data yako"</string>
    <string name="permissions_usage_title" msgid="2942741460679049132">"Dashibodi ya faragha"</string>
    <string name="permissions_usage_summary" msgid="6784310472062516454">"Onyesha programu zilizotumia ruhusa hivi majuzi"</string>
    <string name="unused_apps" msgid="4566272194756830656">"Programu zisizotumika"</string>
    <string name="unused_apps_summary" msgid="4236371818881973021">"{count,plural, =1{Programu # isiyotumika}other{Programu # zisizotumika}}"</string>
    <string name="unused_apps_category" msgid="8954930958175500851">"Mipangilio ya programu zisizotumika"</string>
    <string name="unused_apps_switch" msgid="7595419855882245772">"Simamisha shughuli kwenye programu ikiwa haitumiki"</string>
    <string name="unused_apps_switch_summary" msgid="2171098908014596802">"Ondoa ruhusa, futa faili za muda na usitishe arifa"</string>
    <string name="unused_apps_switch_v2" msgid="7464060328451454469">"Dhibiti programu iwapo haitumiki"</string>
    <string name="unused_apps_switch_summary_v2" msgid="3182898279622036805">"Ondoa ruhusa, futa faili za muda, komesha arifa na uweke programu kwenye kumbukumbu"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Programu Zote"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Programu zilizosakinishwa"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Programu zinazofunguka papo hapo"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Zilizozimwa"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Mipangilio ya kina"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Kidhibiti cha ruhusa"</string>
    <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"Masasisho ya kushiriki data ya mahali"</string>
    <string name="app_data_sharing_updates_summary" msgid="4465929918457739443">"Kagua programu zilizobadilisha jinsi zinavyoweza kushiriki data ya mahali ulipo"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Gusa ili uanze kutumia"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Gusa mara mbili mahali popote kwenye skrini ili uanze kutumia kifaa"</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Kufungua viungo"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Usifungue viungo vinavyoweza kutumika"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Fungua <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Fungua <xliff:g id="DOMAIN">%s</xliff:g> na URL zingine"</string>
    <string name="app_link_open_always" msgid="9167065494930657503">"Ruhusu programu ifungue viungo vinavyotumika"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Uliza kila wakati"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Usiruhusu programu ifungue viungo"</string>
    <string name="app_link_open_always_summary" msgid="4524005594295855117">"{count,plural, =1{Programu inadai kudhibiti kiungo #}other{Programu inadai kudhibiti viungo #}}"</string>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"Programu inadai kudhibiti viungo vifuatavyo:"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Maagizo na usaidizi kwa kutamka"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"Programu ya mratibu dijitali"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"Programu kuu ya mratibu dijitali"</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Kubali"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Programu ya kivinjari"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Programu ya simu"</string>
    <string name="system_app" msgid="1863291702508355041">"(Mfumo)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Hifadhi ya programu"</string>
    <string name="usage_access" msgid="5487993885373893282">"Kufikia matumizi"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Idhinisha ufikiaji wa matumizi"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Muda wa kutumia kifaa"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"Ufikiaji wa matumizi huruhusu programu kufuatilia programu zingine unazotumia na mara ngapi unazitumia, pamoja na mtoa huduma, mipangilio ya lugha, na maelezo yako mengine."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Hifadhi ya kumbukumbu"</string>
    <string name="always_running" msgid="9012705720688200252">"Inatumika wakati wote (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Inayotumika wakati mwingine (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Inayotumiwa kwa nadra (<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">"Kuboresha matumizi ya betri"</string>
    <string name="high_power_filter_on" msgid="447849271630431531">"Haijaboreshwa"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Haijaboreshwa"</string>
    <string name="high_power_off" msgid="317000444619279018">"Uboreshaji wa matumizi ya betri"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Chaguo la kuboresha matumizi ya betri halipo"</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Ungependa kuruhusu programu itumike chinichini kila wakati?"</string>
    <string name="high_power_prompt_body" msgid="6029266540782139941">"Kuruhusu <xliff:g id="APP_NAME">%1$s</xliff:g> itumike chinichini wakati wote kunaweza kupunguza muda wa matumizi ya betri. \n\nUnaweza kubadilisha hali hii baadaye kwenye Mipangilio na Programu."</string>
    <string name="battery_summary" msgid="2491764359695671207">"Imetumia <xliff:g id="PERCENTAGE">%1$s</xliff:g> tangu mwisho ilipojazwa chaji"</string>
    <string name="battery_summary_24hr" msgid="7656033283282656551">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> imetumika katika saa 24 zilizopita"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Betri haijatumika tangu mwisho ilipojazwa chaji"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Ungependa kushiriki ripoti ya hitilafu?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"Msimamizi wako wa TEHAMA ameomba ripoti ya hitilafu ili kusaidia katika utatuzi wa hitilafu kwenye kifaa hiki. Programu na data zinaweza kushirikiwa."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"Msimamizi wako wa TEHAMA ameomba ripoti ya hitilafu ili kusaidia katika utatuzi wa hitilafu katika kifaa hiki. Huenda hatua hii ikashiriki programu na data na kupunguza kasi ya kifaa chako kwa muda."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"Ripoti hii ya hitilafu inashirikiwa na msimamizi wako wa TEHAMA. Wasiliana naye kwa maelezo zaidi."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Shiriki"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Kataa"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Isitumike kuhamisha data"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Chaji kifaa kilichounganishwa"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Uhamishaji wa Faili"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"PTP"</string>
    <string name="usb_use_uvc_webcam" msgid="6595429508472038732">"Kamera ya wavuti"</string>
    <string name="usb_transcode_files" msgid="2441954752105119109">"Badilisha video ziwe AVC"</string>
    <string name="usb_transcode_files_summary" msgid="307102635711961513">"Video zitacheza kwenye vichezaji vingi vya faili za sauti na video, ila huenda ubora ukapungua"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"Kusambaza mtandao kupitia USB"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"Tumia USB"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Mipangilio chaguomsingi ya USB"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Wakati kifaa kingine kimeunganishwa na simu yako imefunguliwa, mipangilio hii itatumika. Unganisha kwenye vifaa unavyoamini pekee."</string>
    <string name="usb_power_title" msgid="5602112548385798646">"Chaguo za kuwasha"</string>
    <string name="usb_file_transfer_title" msgid="2261577861371481478">"Chaguo za kuhamisha faili"</string>
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"Mapendeleo ya USB"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"USB inadhibitiwa na"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Kifaa kilichounganishwa"</string>
    <string name="usb_control_device" msgid="527916783743021577">"Kifaa hiki"</string>
    <string name="usb_switching" msgid="3654709188596609354">"Inabadilisha…"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"Imeshindwa kubadilisha"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Inachaji kifaa hiki"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Inachaji kifaa kilichounganishwa"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Uhamishaji wa faili"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"Kusambaza mtandao kupitia USB"</string>
    <string name="usb_summary_photo_transfers" msgid="7331503733435780492">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2372443732675899571">"MIDI"</string>
    <string name="usb_summary_UVC" msgid="8733131110899174299">"Kamera ya wavuti"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Uhamishaji wa faili na kusambaza nishati"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"Kusambaza mtandao kupitia USB na kusambaza nishati"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP na kusambaza nishati"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"MIDI na kusambaza nishati"</string>
    <string name="usb_summary_UVC_power" msgid="226810354412154061">"Kamera ya wavuti na kusambaza nishati"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Ukaguzi wa chinichini"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Tumia maandishi kutoka skrini"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Ruhusu programu ya usaidizi kufikia maudhui ya skrini kama maandishi"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Tumia picha ya skrini"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Ruhusu programu ya usaidizi kufikia picha ya skrini"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Weka mwako kwenye skrini"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Weka mwako kwenye ukingo wa skrini programu ya usaidizi inapofikia maandishi ya skrini au picha ya skrini"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Programu za usaidizi zinaweza kukusaidia kulingana na maelezo kutoka skrini unayotazama. Baadhi ya programu zinaweza kutumia huduma za kifungua programu na kuweka data kwa kutamka ili kukupa usaidizi wa pamoja."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Wastani wa matumizi ya hifadhi"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Upeo wa matumizi ya hifadhi"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Matumizi ya hifadhi"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Matumizi ya programu"</string>
    <string name="memory_details" msgid="6133226869214421347">"Maelezo"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"Hifadhi ya wastani ya <xliff:g id="SIZE">%1$s</xliff:g> imetumika katika saa 3 zilizopita"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"Hakuna hifadhi iliyotumika katika saa 3 zilizopita"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Panga kwa wastani wa matumizi"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Panga kwa upeo wa matumizi"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Utendaji"</string>
    <string name="total_memory" msgid="5244174393008910567">"Jumla ya hifadhi"</string>
    <string name="average_used" msgid="690235917394070169">"Wastani uliotumika (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Haijatumika"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Hifadhi iliyotumiwa na programu"</string>
    <string name="memory_usage_apps_summary" msgid="7168292864155527974">"{count,plural, =1{Programu 1 imetumia hifadhi katika {time} zilizopita}other{Programu # imetumia hifadhi katika {time} zilizopita}}"</string>
    <string name="force_enable_pss_profiling_title" msgid="2253816522775341523">"Washa utoaji maelezo kuhusu matumizi ya hifadhi"</string>
    <string name="force_enable_pss_profiling_summary" msgid="7714294324548399136">"Utoaji maelezo kuhusu matumizi ya hifadhi unahitaji nyenzo za ziada za mfumo."</string>
    <string name="pss_profiling_disabled" msgid="1967278421143514850">"Kipengele cha utoaji maelezo kuhusu matumizi ya hifadhi kimezimwa"</string>
    <string name="running_frequency" msgid="7260225121706316639">"Masafa"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Upeo wa matumizi"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Hakuna data iliyotumika"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"Je, programu ya <xliff:g id="APP">%1$s</xliff:g> ifikie kipengele cha Usinisumbue?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"Programu itaweza kuzima na kuwasha kipengee cha Usinisumbue na kufanya mabadiliko katika mipangilio inayohusiana."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Lazima kiwe kimewashwa kwa sababu kipengele cha ufikiaji wa arifa kimewashwa"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"Ungependa kubatilisha idhini ya <xliff:g id="APP">%1$s</xliff:g> ya kufikia kipengele cha Usinisumbue?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"Itaondoa sheria zote za Usinisumbue ambazo zimetengenezwa na programu hii."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Usiboreshe"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Boresha"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Huenda ikamaliza chaji ya betri yako haraka zaidi. Programu haitazuiwa tena kutumia betri chinichini."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Imependekezwa kwa muda bora wa matumizi ya betri"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Hamna"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Kuzima idhini ya kufikia matumizi ya programu hii hakutamzuia msimamizi wako kufuatilia matumizi ya data ya programu zilizo katika wasifu wako wa kazini."</string>
    <string name="draw_overlay" msgid="7902083260500573027">"Onyesha juu ya programu zingine"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Kuonyeshwa juu ya programu zingine"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Programu ionekane juu ya zingine"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Ruhusu programu hii ionekane juu ya programu zingine unazotumia. Programu hii itaweza kuona unapogusa au kubadilisha kinachoonyeshwa kwenye skrini."</string>
    <string name="media_routing_control_title" msgid="6402800638960066807">"Badilisha tokeo la maudhui"</string>
    <string name="allow_media_routing_control" msgid="4907036637509360616">"Ruhusu programu ibadilishe tokeo la maudhui"</string>
    <string name="allow_media_routing_description" msgid="8343709701298051207">"Ruhusu programu hii ichague kifaa kilichounganishwa kinachopaswa kucheza maudhui ya sauti au video kutoka kwenye programu nyingine. Ukiiruhusu, programu hii inaweza kufikia orodha ya vifaa vinavyopatikana kama vile vipokea sauti vya kichwani na spika na ichague kifaa cha kutoa maudhui kitakachotumia kutiririsha au kutuma maudhui ya sauti au video."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Kufikia faili zote"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Ruhusu ufikiaji ili idhibiti faili zote"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Ruhusu programu hii isome, irekebishe na kufuta faili zote kwenye kifaa hiki au nafasi zozote za hifadhi zilizounganishwa. Ukiipa ruhusa, huenda programu ikafikia faili bila ufahamu wako."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Inaweza kufikia faili zote"</string>
    <string name="voice_activation_apps_title" msgid="7130045161611529825">"Programu zinazotumia amri ya sauti"</string>
    <string name="permit_voice_activation_apps" msgid="9152780172988949319">"Ruhusu kipengele cha amri ya sauti"</string>
    <string name="allow_voice_activation_apps_description" msgid="6369745626995060656">"Hatua ya kuwezesha sauti huwasha programu zilizoidhinishwa, bila kutumia mikono, kupitia amri ya sauti. Kipengele kilichojumuishwa cha utambuzi unaotegemea mazingira huhakikisha kuwa ni wewe tu unayeweza kuona data.\n\n"<a href="">"Maelezo zaidi kuhusu utambuzi unaotegemea mazingira"</a></string>
    <string name="full_screen_intent_title" msgid="747270185715224130">"Arifa za skrini nzima"</string>
    <string name="permit_full_screen_intent" msgid="9035367640019960861">"Ruhusu programu hii ionyeshe arifa kwenye skrini nzima"</string>
    <string name="footer_description_full_screen_intent" msgid="7716518411349225528">"Ruhusu programu hii ionyeshe arifa kwenye skrini nzima ukiwa umefunga kifaa. Programu zinaweza kutumia arifa hizi kuonyesha kengele, simu unazopigiwa au arifa nyingine muhimu."</string>
    <string name="media_management_apps_title" msgid="8222942355578724582">"Programu za kudhibiti maudhui"</string>
    <string name="media_management_apps_toggle_label" msgid="166724270857067456">"Ruhusu programu idhibiti maudhui"</string>
    <string name="media_management_apps_description" msgid="8000565658455268524">"Ikiruhusiwa, programu hii inaweza kubadilisha au kufuta faili za maudhui zilizoundwa na programu zingine bila kukuomba ruhusa. Ni sharti programu iwe na ruhusa ili ifikie faili na maudhui."</string>
    <string name="keywords_media_management_apps" msgid="7499959607583088690">"Maudhui, Faili, Usimamizi, Kidhibiti, Dhibiti, Badilisha, Kihariri, Programu, Programu, Programu"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"vr uhalisia pepe kisikilizaji stereo kisaidizi huduma"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Onyesha juu ya programu zingine"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Programu zilizo na ruhusa"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Imeruhusiwa"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Hairuhusiwi"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"sakinisha programu kutoka vyanzo visivyojulikana"</string>
    <string name="write_settings" msgid="6864794401614425894">"Kubadilisha mipangilio ya mfumo"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"andika rekebisha mipangilio ya mfumo"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Inaweza kusakinisha programu zingine"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Inaweza kubadilisha mipangilio ya mfumo"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Inaweza kubadilisha mipangilio ya mfumo"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Kubadilisha mipangilio ya mfumo"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Ruhusu ubadilishaji wa mipangilio ya mfumo"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Idhini hii huruhusu programu kubadilisha mipangilio ya mfumo"</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Ruhusu kutoka chanzo hiki"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Kunja mkon mara mbili ili ufungue kamera"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Fungua programu ya kamera kwa kukunja kifundo cha mkono wako mara mbili"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Ukubwa wa vipengee"</string>
    <string name="screen_zoom_short_summary" msgid="756254364808639194">"Fanya kila kitu kiwe kikubwa zaidi au kidogo zaidi"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"onyesha uzito, kukuza skrini, kipimo, kupima"</string>
    <string name="screen_zoom_preview_title" msgid="5288355628444562735">"Kagua kwanza"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Punguza"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Kuza"</string>
    <string name="disconnected" msgid="3469373726996129247">"Haujaunganishwa"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Haijaunganishwa"</string>
    <string name="apps_summary" msgid="4007416751775414252">"Programu <xliff:g id="COUNT">%1$d</xliff:g> zimesakinishwa"</string>
    <string name="storage_summary" msgid="5903562203143572768">"Nafasi iliyotumika - <xliff:g id="PERCENTAGE">%1$s</xliff:g>. Zimesalia <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="display_dashboard_summary" msgid="1599453894989339454">"Mandhari meusi, ukubwa wa fonti, ung\'aavu"</string>
    <string name="memory_summary" msgid="8221954450951651735">"Takriban <xliff:g id="USED_MEMORY">%1$s</xliff:g> kati ya <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g> za hifadhi zimetumika"</string>
    <string name="users_summary" msgid="8473589474976307510">"Umeingia katika akaunti kama <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Imesasishwa na inatumia Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"Sasisho linapatikana"</string>
    <string name="disabled_by_policy_title" msgid="6852347040813204503">"Imezuiwa na sera ya mahali pako pa kazi"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Haiwezi kubadilisha sauti"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="400089720689494562">"Huwezi kupiga simu"</string>
    <string name="disabled_by_policy_title_sms" msgid="8951840850778406831">"Huwezi kutuma ujumbe wa SMS"</string>
    <string name="disabled_by_policy_title_camera" msgid="6616508876399613773">"Huwezi kutumia kamera"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6085100101044105811">"Huwezi kupiga picha za skrini"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Haiwezi kufungua programu"</string>
    <string name="disabled_by_policy_title_financed_device" msgid="2328740314082888228">"Imezuiwa na kampuni iliyokuuzia kifaa kwa mkopo"</string>
    <string name="disabled_by_policy_title_biometric_parental_consent" msgid="2463673997797134678">"Mzazi anahitajika"</string>
    <string name="disabled_by_policy_content_biometric_parental_consent" msgid="7124116806784305206">"Mpe mzazi wako simu ili kuanza kuweka mipangilio hii"</string>
    <string name="disabled_by_policy_parental_consent" msgid="9166060049019018978">"Mpatie mzazi wako simu ili kuruhusu mipangilio hii kubadilishwa."</string>
    <string name="default_admin_support_msg" msgid="8816296554831532033">"Ili upate maelezo zaidi, wasiliana na Msimamizi wako wa TEHAMA"</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Maelezo zaidi"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"Msimamizi wako anaweza kufuatilia na kudhibiti programu na data zinazohusiana na wasifu wako wa kazini, ikiwa ni pamoja na mipangilio, ruhusa, ufikiaji wa shirika, shughuli za mtandao na maelezo ya mahali kilipo kifaa."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"Msimamizi wako anaweza kufuatilia na kudhibiti programu na data zinazohusiana na mtumiaji huyu, ikiwa ni pamoja na mipangilio, ruhusa, ufikiaji wa shirika, shughuli za mtandao na maelezo ya mahali kilipo kifaa."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"Msimamizi wako anaweza kufuatilia na kudhibiti programu na data zinazohusiana na kifaa hiki, ikiwa ni pamoja na mipangilio, ruhusa, ufikiaji wa shirika, shughuli za mtandao na maelezo ya mahali kilipo kifaa."</string>
    <string name="admin_financed_message" msgid="1156197630834947884">"Msimamizi wa kifaa chako anaweza kufikia data inayohusiana na kifaa hiki, kudhibiti programu na kubadilisha mipangilio ya kifaa hiki."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Zima"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Washa"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Onyesha"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Ficha"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"Mtandaopepe unatumika"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Hali ya ndegeni imewashwa"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Mitandao haipatikani"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"Umewasha kipengele cha Usinisumbue"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Umezima sauti ya simu"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"Ikiwa na hali maalum"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Kiokoa Betri kimewashwa"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Vipengele vilivyozuiwa"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Umezima data ya mtandao wa simu"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Intaneti inapatikana kupitia Wi‑Fi pekee"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Kiokoa Data"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Vipengele vilivyozuiwa"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Wasifu wa kazini umezimwa"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Kwa ajili ya programu na arifa"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Washa sauti"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Umezima sauti ya programu inayotoa milio ya simu"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Kwa ajili ya simu na arifa"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Mtetemo pekee"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Kwa ajili ya simu na arifa"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Weka ratiba ya Mwanga wa Usiku"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Geuza rangi ya skrini kiotomatiki kila usiku"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"Mwanga wa Usiku umewashwa"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Skrini yenye rangi maalum ya machungwa"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Kijivu"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Onyesha tu katika rangi ya kijivu"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Kunja"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Halijoto ya rangi ya baridi"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Tumia rangi yenye halijoto ya baridi zaidi kwenye onyesho"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Zima skrini ili uweze kutekeleza ubadilishaji wa rangi"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Kitambuzi cha Leza cha Kamera"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Masasisho ya mfumo kiotomatiki"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Weka masasisho kifaa kitakapozimwa na kuwashwa"</string>
    <string name="usage" msgid="287782903846013936">"Matumizi"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Matumizi ya data ya mtandao wa simu"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Programu zinavyotumia data"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"Matumizi ya data ya Wi-Fi"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Matumizi ya data isiyo ya mtoa huduma"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Matumizi ya data ya ethaneti"</string>
    <string name="wifi" msgid="2932584495223243842">"Wi-Fi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Ethaneti"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"Data ya mtandao wa simu <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"Data ya Wi-Fi <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"Data ya ethaneti <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Onyo la kikomo na matumizi ya data"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Matumizi ya data ya mtandao wa simu"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"Onyo la matumizi ya data: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"Kikomo cha data: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"Onyo la matumizi ya data: <xliff:g id="ID_1">^1</xliff:g> / Kikomo cha data: <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="non_carrier_data_usage_warning" msgid="4707184871368847697">"Haijumuishi data inayotumiwa na mitandao ya mtoa huduma"</string>
    <string name="data_used_template" msgid="8229342096562327646">"<xliff:g id="ID_1">%1$s</xliff:g> zimetumika"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Weka onyo la matumizi ya data"</string>
    <string name="data_warning" msgid="2925054658166062884">"Onyo kuhusu data"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"Kikomo na onyo la data hupimwa na kifaa chako. Kipimo hiki huenda kikawa tofauti na data ya mtoa huduma wako."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Weka kikomo cha data"</string>
    <string name="data_limit" msgid="8731731657513652363">"Kikomo cha data"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"<xliff:g id="ID_1">%1$s</xliff:g> zimetumika kuanzia <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="configure" msgid="1499586749829665889">"Weka mipangilio"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Programu zingine zilizojumuishwa katika matumizi"</string>
    <string name="data_saver_unrestricted_summary" msgid="7343571401172437542">"{count,plural, =1{Programu 1 imeruhusiwa kutumia data ambayo haijadhibitiwa wakati Kiokoa Data kimewashwa}other{Programu # zimeruhusiwa kutumia data ambayo haijadhibitiwa wakati Kiokoa Data kimewashwa}}"</string>
    <string name="data_usage_title" msgid="4039024073687469094">"Data ya msingi"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"Data ya Wi‑Fi"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"Umetumia <xliff:g id="ID_2">^2</xliff:g> <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_overusage" msgid="3680477320458707259">"Zaidi ya <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_remaining" msgid="6316251496381922837">"Zimesalia <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Grafu inayoonyesha matumizi ya data kati ya tarehe <xliff:g id="START_DATE">%1$s</xliff:g> na <xliff:g id="END_DATE">%2$s</xliff:g>."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"Hakuna data katika kipindi hiki"</string>
    <string name="billing_cycle_days_left" msgid="174337287346866400">"{count,plural, =1{Imebaki siku #}other{Zimebaki siku #}}"</string>
    <string name="billing_cycle_none_left" msgid="1694844019159277504">"Hakuna muda unaosalia"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Imesalia chini ya siku 1"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"Imesasishwa na <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g> zilizopita"</string>
    <string name="no_carrier_update_text" msgid="5432798085593055966">"Imesasishwa <xliff:g id="ID_1">^2</xliff:g> zilizopita"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Imesasishwa na <xliff:g id="ID_1">^1</xliff:g> sasa hivi"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Imesasishwa sasa hivi"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Angalia maelezo"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Kiokoa Data"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Data bila kipimo"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Data ya chini chini imezimwa"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"Kimewashwa"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Kimezimwa"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Tumia Kiokoa Data"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Matumizi ya data bila vikwazo"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Ruhusu ufikiaji wa data bila vikwazo wakati Kiokoa Data kimewashwa"</string>
    <string name="home_app" msgid="6056850504746902747">"Programu ya ukurasa wa mwanzo"</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Ongeza alama nyingine ya kidole"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Fungua kwa kidole tofauti"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"Kimewashwa"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Kitawaka chaji ya betri ikifika <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Kimezimwa"</string>
    <string name="app_battery_usage_title" msgid="346558380609793334">"Programu inavyotumia betri"</string>
    <string name="app_battery_usage_summary" msgid="6349965904306339539">"Weka matumizi ya betri kwa ajili ya programu"</string>
    <string name="battery_tips_card_action_button" msgid="4897793527424711648">"Tazama Mipangilio"</string>
    <string name="battery_tips_card_action_button_check" msgid="1535140204105479318">"Imetiwa alama"</string>
    <string name="battery_tips_card_dismiss_button" msgid="1885756985544936618">"Nimeelewa"</string>
    <string name="battery_tips_card_feedback_info" msgid="767117835675157298">"Je, ujumbe huu umekusaidia?"</string>
    <string name="battery_hints_warning_icon_a11y" msgid="5312542323401447620">"Aikoni ya onyo ya vidokezo vya betri"</string>
    <string name="battery_tips_settings_summary_brightness" msgid="546145032616077783">"Washa kipengele cha mwangaza unaojirekebisha ili uongeze muda wa matumizi ya betri"</string>
    <string name="battery_tips_settings_summary_screen_timeout" msgid="556801426050962077">"Punguza muda wa skrini kujizima ili uongeze muda wa matumizi ya betri"</string>
    <string name="battery_tips_apps_summary_always_high" msgid="6334519477067044920">"<xliff:g id="APP_LABEL">%1$s</xliff:g> imetumia betri zaidi"</string>
    <string name="battery_tips_apps_summary_higher_than_usual" msgid="95676961671544628">"<xliff:g id="APP_LABEL">%1$s</xliff:g> imetumia betri zaidi kuliko kawaida"</string>
    <string name="battery_tips_apps_summary_always_high_in_background" msgid="2953858181710181126">"<xliff:g id="APP_LABEL">%1$s</xliff:g> imetumia betri zaidi chinichini"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_background" msgid="1585002072567422199">"<xliff:g id="APP_LABEL">%1$s</xliff:g> imetumia betri zaidi kuliko kawaida ikiwa chinichini"</string>
    <string name="battery_tips_apps_summary_always_high_in_foreground" msgid="1910991243576404700">"<xliff:g id="APP_LABEL">%1$s</xliff:g> imetumia betri zaidi wakati programu inatumika"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_foreground" msgid="7937337570425168210">"<xliff:g id="APP_LABEL">%1$s</xliff:g> imetumia betri zaidi kuliko kawaida wakati programu inatumika"</string>
    <string name="battery_usage_anomaly_content_description" msgid="3199380151630770476">"Hitilafu ya matumizi ya betri"</string>
    <string name="battery_app_item_hint" msgid="4850929961461039110">"Matumizi ya juu ya betri"</string>
    <string name="battery_app_item_hint_in_bg" msgid="596240821466388336">"Matumizi ya juu ya betri chinichini"</string>
    <string name="battery_app_item_hint_in_fg" msgid="5091860632260799910">"Matumizi ya juu ya betri wakati programu inatumika"</string>
    <string name="filter_battery_unrestricted_title" msgid="821027369424198223">"Isiyodhibitiwa"</string>
    <string name="filter_battery_optimized_title" msgid="8236647176487754796">"Iliyoboreshwa"</string>
    <string name="filter_battery_restricted_title" msgid="5886859505802563232">"Inayodhibitiwa"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Kikagua tahajia chaguomsingi"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Chagua kikagua tahajia"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Tumia kikagua maendelezo"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Hakijachaguliwa"</string>
    <string name="notification_log_details_delimiter" msgid="2475986465985309821">": "</string>
    <string name="notification_log_details_package" msgid="3205243985502010202">"kifurushi"</string>
    <string name="notification_log_details_key" msgid="2690467272328709046">"ufunguo"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"kikundi"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(muhtasari)"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"Toleo la hadharani"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"umuhimu"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"maelezo"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"Inaweza kuonyesha beji"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"utaratibu wa kuratibu"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"futa utaratibu wa kuratibu"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"utaratibu wa kuratibu skrini nzima"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"vitendo"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"kichwa"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"data inayoingizwa kwa mbali"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"mwonekano maalum"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"za ziada"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"aikoni"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"ukubwa wa sehemu"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"hifadhi inayoshirikiwa katika Android"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"imewasilisha arifa"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"kituo"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Haina kipengele cha kuorodhesha."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"Kipengele cha kuorodhesha hakina ufunguo huu."</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Mkato kwenye skrini"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"mwonekano wenye pengo, mkato wa umbo"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Hali chaguomsingi ya kifaa"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Imeshindwa kutumia tangazo lililowekelewa juu"</string>
    <string name="special_access" msgid="1767980727423395147">"Idhini maalum za programu"</string>
    <string name="special_access_more" msgid="132919514147475846">"Angalia zaidi"</string>
    <string name="long_background_tasks_label" msgid="3169590134850226687">"Majukumu ya muda mrefu yanayoendelea chinichini"</string>
    <string name="long_background_tasks_switch_title" msgid="2491623894899492543">"Ruhusu majukumu yanayotekelezwa chinichini kwa muda mrefu"</string>
    <string name="long_background_tasks_title" msgid="3272230637974707490">"Majukumu ya muda mrefu yanayoendelea chinichini"</string>
    <string name="long_background_tasks_footer_title" msgid="9117342254914743097">"Ruhusu programu hii itekeleze majukumu ya muda marefu yanayoendelea chinichini. Kitendo hiki huruhusu programu itekeleze majukumu ambayo yanaweza kuchukua muda mrefu zaidi ya dakika chache kukamilika, kama vile upakuaji na upakiaji. \n\nRuhusa hii ikikataliwa, mfumo utawekea kikomo muda ambao programu inaweza kutekeleza majukumu haya yanayoendelea chinichini."</string>
    <string name="keywords_long_background_tasks" msgid="5788956269136054574">"kazi ndefu, uhamishaji wa data, majukumu yanayoendelea chinichini"</string>
    <string name="run_backup_tasks_title" msgid="8572480651659803275">"Tekeleza majukumu ya kuhifadhi nakala chinichini"</string>
    <string name="run_backup_tasks_switch_title" msgid="4740767959730361777">"Ruhusu programu itekeleze majukumu yanayohusiana na kuhifadhi nakala chinichini"</string>
    <string name="run_backup_tasks_footer_title" msgid="1766222193265152388">"Huashiria kuwa programu hii ina kesi kuu ya matumizi ambapo inahitaji kuhifadhi nakala au kusawazisha maudhui. Kutoa ruhusa hii huwezesha programu kutumika chinichini kwa muda mrefu zaidi ili ikamilishe kazi zinazohusiana na kuhifadhi nakala. \n\nRuhusa hii ikikataliwa, mfumo hautatoa ruhusa yoyote maalum kwa programu hii kukamilisha kazi inayohusiana na kuhifadhi nakala chinichini."</string>
    <string name="keywords_run_backup_tasks" msgid="632219905465766211">"hifadhi nakala ya majukumu, hifadhi nakala ya kazi"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Weka upya mipangilio ya udhibiti wa ukadiriaji katika Kidhibiti cha Njia za Mkato"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"Imeweka upya mipangilio ya udhibiti wa ukadiriaji katika Kidhibiti cha Njia za Mkato"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Dhibiti maelezo kwenye skrini iliyofungwa"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Onyesha au ufiche maudhui ya arifa"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Vidokezo na usaidizi"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Upana mdogo zaidi"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Hakuna programu zilizosakinishwa ambazo zimeomba kufikia huduma ya SMS zinazolipiwa"</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"Gharama ya huduma ya SMS zinazolipiwa itajumuishwa kwenye bili yako ya mtoa huduma. Ikiwa utatoa ruhusa ya programu fulani, utaweza kutuma SMS zinazolipiwa ukitumia programu hiyo."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Kufikia huduma ya SMS zinazolipiwa"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Imezimwa"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Imeunganishwa kwenye <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Imeunganishwa kwenye vifaa vingi"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Hali ya onyesho la kiolesura cha mfumo"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Mandhari meusi"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Imezimwa kwa muda kwa sababu ya Kiokoa Betri"</string>
    <string name="ambient_camera_summary_battery_saver_on" msgid="1787784892047029560">"Imezimwa kwa muda kwa sababu ya Kiokoa Betri"</string>
    <string name="ambient_camera_battery_saver_off" msgid="689825730569761613">"Zima kiokoa betri"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Imewashwa kwa muda kwa sababu ya Kiokoa Betri"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Jaribu Mandhari meusi"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Huboresha muda wa matumizi ya betri"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Vigae vya msanidi programu vya mipangilio ya haraka"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Zima kuisha kwa muda wa uidhinishaji wa adb"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Zima ubatilishaji wa kiotomatiki wa uidhinishaji wa adb wa mifumo ambayo haijaunganishwa katika kipindi chaguomsingi (siku saba) au muda uliowekwa na mtumiaji (angalau siku moja)."</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Vitambuzi Vimezimwa"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Mipangilio ya wasifu wa kazini"</string>
    <string name="managed_profile_contact_search_title" msgid="6562061740814513737">"Tafuta anwani za saraka ya kazini katika programu za binafsi"</string>
    <string name="managed_profile_contact_search_summary" msgid="4974727886709219105">"Msimamizi wako wa TEHAMA anaweza kuona utafutaji na simu ulizopigiwa"</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Kalenda ya akaunti unayoweza kusawazisha"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Onyesha matukio ya kazi kwenye kalenda yako ya binafsi"</string>
    <string name="managed_profile_settings_footer" msgid="996500759305118103">"Wakati programu za kazini zimezimwa, huwa zinasitishwa na haziwezi kufikiwa au kukutumia arifa"</string>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Dhibiti hifadhi"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"Ili kuongeza nafasi ya hifadhi, kidhibiti cha hifadhi huondoa picha na video zilizohifadhiwa nakala kwenye kifaa chako."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Ondoa picha na video"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Kidhibiti cha hifadhi"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Tumia Kidhibiti cha hifadhi"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Ishara"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Fungua kamera haraka"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Ili ufungue kamera haraka, bofya kitufe cha kuwasha/kuzima mara mbili. Hufanya kazi katika skrini yoyote."</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Geuza kamera ili upige selfi"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="system_navigation_title" msgid="4890381153527184636">"Hali ya kusogeza"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Usogezaji kwa kutumia vitufe 2"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"Ili ubadilishe programu, telezesha kidole juu kwenye kitufe cha Ukurasa wa mwanzo. Ili uone programu zote, telezesha kidole juu tena. Ili urudi nyuma, gusa kitufe cha kurudi nyuma."</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Usalama na dharura"</string>
    <string name="emergency_dashboard_summary" msgid="401033951074039302">"Simu ya dharura, maelezo ya matibabu, arifa"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Usogezaji kwa kutumia ishara"</string>
    <string name="edge_to_edge_navigation_summary" msgid="818109176611921504">"Ili uende kwenye skrini ya kwanza, telezesha kidole juu kutoka sehemu ya chini ya skrini. Ili ubadilishe programu, telezesha kidole juu kutoka sehemu ya chini ya skrini kisha ushikilie, halafu uachilie. Ili urudi nyuma, telezesha kidole kutoka ukingo wa kushoto au kulia."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"Usogezaji kwa kutumia vitufe 3"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Rudi nyuma, Skrini ya kwanza na ubadilishe programu ukitumia vitufe vilivyo sehemu ya chini ya skrini yako."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"usogezaji kwenye mfumo, usogezaji kwa kutumia vitufe 2, usogezaji kwa kutumia vitufe 3, usogezaji kwa kutumia ishara, telezesha kidole"</string>
    <string name="assistant_gesture_category_title" msgid="2478251256585807920">"Mratibu dijitali"</string>
    <string name="assistant_corner_gesture_title" msgid="1895061522687002106">"Telezesha kidole ili uombe programu ya mratibu dijitali"</string>
    <string name="assistant_corner_gesture_summary" msgid="5012534700233017955">"Telezesha kidole juu kutoka kona ya chini ili uombe programu ya mratibu dijitali"</string>
    <string name="assistant_long_press_home_gesture_title" msgid="4865972278738178753">"Shikilia kitufe cha Mwanzo ili uombe Mratibu"</string>
    <string name="assistant_long_press_home_gesture_summary" msgid="592882226105081447">"Bonyeza na ushikilie Kitufe cha ukurasa wa mwanzo ili uombe programu ya mratibu dijitali."</string>
    <string name="low_label" msgid="6525629096999711220">"Chini"</string>
    <string name="high_label" msgid="357503396626018487">"Juu"</string>
    <string name="left_edge" msgid="1513576842959071849">"Ukingo wa kushoto"</string>
    <string name="right_edge" msgid="1505309103265829121">"Ukingo wa kulia"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"Kiwango cha juu cha hisi kinaweza kukinzana na ishara zozote za programu kwenye kingo za skrini."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Hisi za Nyuma"</string>
    <string name="gesture_settings_activity_title" msgid="2025828425762595733">"Ung\'avu wa Usogezaji kwa Kutumia Ishara"</string>
    <string name="button_navigation_settings_activity_title" msgid="7335636045504461813">"Usogezaji kwa kutumia kitufe"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"usogezaji kwa kutumia ishara, kiwango cha hisi ya nyuma, ishara ya nyuma"</string>
    <string name="keywords_button_navigation_settings" msgid="7888812253110553920">"usogezaji, kitufe cha ukurasa wa mwanzo"</string>
    <string name="one_handed_title" msgid="2584414010282746195">"Hali ya kutumia kwa mkono mmoja"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Tumia hali ya kutumia kwa mkono mmoja"</string>
    <string name="one_handed_mode_shortcut_title" msgid="1847871530184067369">"Njia ya mkato ya hali ya kutumia kwa mkono mmoja"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"uwezo wa kufikia"</string>
    <string name="one_handed_mode_swipe_down_category" msgid="110178629274462484">"Telezesha kidole chini uweze"</string>
    <string name="one_handed_mode_use_shortcut_category" msgid="1414714099339147711">"Tumia njia ya mkato kutekeleza"</string>
    <string name="one_handed_mode_intro_text" msgid="7921988617828924342">"Vuta chini nusu ya sehemu ya juu ya skrini yako ili ufanye iwe rahisi kufikia kwa mkono mmoja"</string>
    <string name="one_handed_mode_footer_text" msgid="6336209800330679840">" "<b>"Jinsi ya kutumia kipengele cha hali ya kutumia kwa mkono mmoja"</b>\n" • Hakikisha kwamba usogezaji kwa kutumia ishara umechaguliwa katika mipangilio ya usogezaji kwenye mfumo\n • Telezesha kidole chini karibu na ukingo wa chini wa skrini"</string>
    <string name="one_handed_action_pull_down_screen_title" msgid="9187194533815438150">"Kusogeza skrini karibu nawe"</string>
    <string name="one_handed_action_pull_down_screen_summary" msgid="7582432473450036628">"Utaweza kufikia sehemu ya juu ya skrini ukitumia kidole gumba chako."</string>
    <string name="one_handed_action_show_notification_title" msgid="8789305491485437130">"Kuonyesha arifa"</string>
    <string name="one_handed_action_show_notification_summary" msgid="8281689861222000436">"Arifa na mipangilio itaonekana."</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Ili uangalie saa, arifa na maelezo mengine, gusa skrini yako mara mbili."</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Onyesho la kuwasha skrini"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Ili uangalie saa, arifa na maelezo mengine, gusa skrini yako."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"Simu ya dharura"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7421353963329899514">"Tumia kipengele cha Simu ya dharura"</string>
    <string name="emergency_gesture_screen_summary" msgid="6640521030845132507">"Bonyeza Kitufe cha kuwasha/kuzima haraka mara tano au zaidi ili uanzishe vitendo vilivyo hapa chini"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Cheza kengele ya muda uliosalia"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="6573377104470235173">"Cheza sauti ya kiwango cha juu Simu ya dharura inapoanza"</string>
    <string name="emergency_gesture_category_call_for_help_title" msgid="1680040129478289510">"Arifu ili upate usaidizi"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Piga simu ili upate usaidizi"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Nambari ya kupiga ili upate usaidizi"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Gusa ili ubadilishe"</string>
    <string name="emergency_gesture_number_override_notes" msgid="233018570696200402">"Ukiweka namba isiyo ya dharura:\n • Ni sharti kifaa chako kifunguliwe ili utumie kipengele cha Simu ya dharura\n • Huenda simu yako isijibiwe"</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Telezesha kidole ili upate arifa"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Telezesha kidole"</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Angalia arifa haraka"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"Imewashwa"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Imezimwa"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"Tayari kipakiaji cha mfumo wa uendeshaji kimefunguliwa"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Unganisha kwenye intaneti au uwasiliane na mtoa huduma wako"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Haipatikani kwenye baadhi ya vifaa vilivyofungwa na mtoa huduma"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Tafadhali zima kisha uwashe kifaa ili kuwasha kipengele cha ulinzi wa kifaa."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"Imepata <xliff:g id="SIZE">%1$s</xliff:g>\n\nIlitumika mara ya mwisho tarehe <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="6654581786741216382">"Programu zinazofunguka papo hapo"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Fungua viungo katika programu, hata kama programu hazijasakinishwa"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Programu zinazofunguka papo hapo"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Mapendeleo ya Programu Zinazofunguka Papo Hapo"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Programu zilizosakinishwa"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Hifadhi yako sasa inasimamiwa na kidhibiti cha hifadhi"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Akaunti za <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Sawazisha data ya programu kiotomatiki"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Ruhusu programu zipakie data upya kiotomatiki"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Usawazishaji akaunti"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Umewasha usawazishaji katika vipengee <xliff:g id="ID_1">%1$d</xliff:g> kati ya <xliff:g id="ID_2">%2$d</xliff:g>"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Umewasha usawazishaji katika vipengee vyote"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Umezima usawazishaji katika vipengee vyote"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Maelezo kuhusu kifaa kinachosimamiwa"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Mabadiliko na mipangilio inayosimamiwa na shirika lako"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Mabadiliko na mipangilio inayosimamiwa na <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"Ili kutoa idhini ya kufikia data yako ya kazini, shirika lako linaweza kubadilisha mipangilio na kusakinisha programu kwenye kifaa chako. \n\nWasiliana na msimamizi wa shirika lako ili upate maelezo zaidi."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Aina ya maelezo ambayo shirika lako linaweza kuona"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Mabadiliko yaliyofanywa na msimamizi wa shirika lako"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Idhini yako ya kufikia kifaa hiki"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Data inayohusiana na akaunti yako ya kazini, kama vile barua pepe na kalenda"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Orodha ya programu zilizo kwenye kifaa chako"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Muda na data iliyotumika katika kila programu"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Kumbukumbu ya hivi majuzi zaidi ya shughuli kwenye mtandao"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Ripoti ya hivi karibuni ya hitilafu"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Kumbukumbu ya hivi majuzi ya usalama"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Hamna"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Programu zilizosakinishwa"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"Tumekadiria idadi ya programu. Huenda haijajumuisha programu ulizosakinisha kutoka nje ya Duka la Google Play."</string>
    <string name="enterprise_privacy_number_packages_lower_bound" msgid="5317634640873658149">"{count,plural, =1{Angalau programu #}other{Angalau programu #}}"</string>
    <string name="enterprise_privacy_location_access" msgid="8023838718108456971">"Ruhusa za mahali"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Ruhusa za maikrofoni"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Ruhusa za kamera"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Programu chaguomsingi"</string>
    <string name="enterprise_privacy_number_packages" msgid="5294444005035188274">"{count,plural, =1{Programu #}other{Programu #}}"</string>
    <string name="enterprise_privacy_input_method" msgid="3278314982700662246">"Kibodi chaguomsingi"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Weka kuwa <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"VPN iwe imewashwa kila wakati"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"Kila mara VPN iwe imewashwa kwenye wasifu wako wa binafsi"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"Kila mara VPN iwe imewashwa kwenye wasifu wako wa kazini"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Seva mbadala ya HTTP ya jumla iwekekwa"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Stakabadhi zinazoaminika"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Kitambulisho cha kuaminika katika wasifu wako wa binafsi"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Kitambulisho cha kuaminika katika wasifu wako wa kazini"</string>
    <string name="enterprise_privacy_number_ca_certs" msgid="4540897122831942658">"{count,plural, =1{Angalau cheti # cha CA}other{Angalau vyeti # vya CA}}"</string>
    <string name="enterprise_privacy_lock_device" msgid="464054894363899866">"Msimamizi anaweza kufunga kifaa na kubadilisha nenosiri"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"Msimamizi anaweza kufuta data yote ya kifaa"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Data yote ya kifaa ijifute baada ya kujaribu kuweka nenosiri lisilo sahihi mara nyingi mno"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Data yote ya wasifu wa kazini ijifute baada ya kujaribu kuweka nenosiri lisilo sahihi mara nyingi mno"</string>
    <string name="enterprise_privacy_number_failed_password_wipe" msgid="2695842143305867642">"{count,plural, =1{Jaribio #}other{Majaribio #}}"</string>
    <string name="do_disclosure_generic" msgid="3067459392402324538">"Kifaa hiki kinadhibitiwa na shirika lako."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"Kifaa hiki kinasimamiwa na <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">"Pata maelezo zaidi"</string>
    <string name="blocked_by_restricted_settings_title" msgid="7334715011474037399">"Mipangilio iliyozuiliwa"</string>
    <string name="toast_allows_restricted_settings_successfully" msgid="1219116121291466102">"Mipangilio iliyozuiliwa imeruhusiwa kwa <xliff:g id="APP_NAME">%s</xliff:g>"</string>
    <string name="blocked_by_restricted_settings_content" msgid="3628660029601161080">"Kwa ajili ya usalama wako, mpangilio huu haupatikani kwa sasa."</string>
    <string name="financed_privacy_settings" msgid="2575114436197204145">"Maelezo kuhusu kifaa kilichonunuliwa kwa mkopo"</string>
    <string name="financed_privacy_intro" msgid="7836497475568741579">"Muuzaji wako wa vifaa kwa mkopo anaweza kubadilisha mipangilio na kusakinisha programu kwenye kifaa hiki wakati wa kuweka mipangilio.\n\nIwapo utashindwa kufanya malipo, muuzaji wako wa vifaa kwa mkopo anaweza kufunga kifaa chako na kubadilisha mipangilio ya kifaa.\n\nIli upate maelezo zaidi, wasiliana na muuzaji wako wa vifaa kwa mkopo."</string>
    <string name="financed_privacy_restrictions_category" msgid="2472659467919651602">"Ikiwa kifaa chako kimenunuliwa kwa mkopo, hutaweza:"</string>
    <string name="financed_privacy_install_apps" msgid="7381718005710210851">"Sakinisha programu kutoka nje ya Duka la Google Play"</string>
    <string name="financed_privacy_safe_mode" msgid="5362149445732602578">"Kuwasha kifaa chako tena katika hali salama"</string>
    <string name="financed_privacy_multi_users" msgid="1727194928477613081">"Kuongeza watumiaji wengi kwenye kifaa chako"</string>
    <string name="financed_privacy_config_date_time" msgid="8567370445374984365">"Badilisha tarehe, saa na saa za eneo"</string>
    <string name="financed_privacy_developer_options" msgid="7602001474669831672">"Tumia chaguo za wasanidi programu"</string>
    <string name="financed_privacy_credit_provider_capabilities_category" msgid="8737902277892987998">"Muuzaji wako wa vifaa kwa mkopo anaweza:"</string>
    <string name="financed_privacy_IMEI" msgid="1852413860963824799">"Fikia namba yako ya IMEI"</string>
    <string name="financed_privacy_factory_reset" msgid="5505016667590160732">"Rejesha mipangilio ambayo kifaa chako kilitoka nayo kiwandani endapo hitilafu itatokea"</string>
    <string name="financed_privacy_locked_mode_category" msgid="3708288398912647751">"Iwapo kifaa chako kimefungwa, utaweza kukitumia kufanya yafuatayo pekee:"</string>
    <string name="financed_privacy_emergency_calls" msgid="1108183987142736497">"Piga simu za dharura"</string>
    <string name="financed_privacy_system_info" msgid="4158031444108708927">"Kutazama maelezo ya mfumo kama vile tarehe, saa, hali ya mtandao na betri"</string>
    <string name="financed_privacy_turn_on_off_device" msgid="3331566753152790571">"Kuwasha au kuzima kifaa chako"</string>
    <string name="financed_privacy_notifications" msgid="5932303271274089968">"Kutazama arifa na SMS"</string>
    <string name="financed_privacy_allowlisted_apps" msgid="8333040812194879963">"Fikia programu zinazoruhusiwa na muuzaji vifaa kwa mkopo"</string>
    <string name="financed_privacy_fully_paid_category" msgid="9221763928564246923">"Baada ya kulipa kiasi kamili:"</string>
    <string name="financed_privacy_restrictions_removed" msgid="3182636815294595072">"Vizuizi vyote vitaondolewa kwenye kifaa"</string>
    <string name="financed_privacy_uninstall_creditor_app" msgid="6339004120497310705">"Unaweza ondoa programu ya muuzaji wa vifaa kwa mkopo"</string>
    <string name="financed_device_info" msgid="3871860346697308342">"Maelezo kuhusu kifaa kilichonunuliwa kwa mkopo"</string>
    <string name="default_camera_app_title" msgid="6546248868519965998">"{count,plural, =1{Programu ya kamera}other{Programu za kamera}}"</string>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Programu ya kalenda"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Programu ya anwani"</string>
    <string name="default_email_app_title" msgid="5411280873093244250">"{count,plural, =1{Programu ya barua pepe}other{Programu za barua pepe}}"</string>
    <string name="default_map_app_title" msgid="7569231732944853320">"Programu ya ramani"</string>
    <string name="default_phone_app_title" msgid="795025972645464135">"{count,plural, =1{Programu ya simu}other{Programu za simu}}"</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">"Kifaa hiki"</string>
    <string name="storage_games" msgid="1176568610086802469">"Michezo"</string>
    <string name="storage_files" msgid="7968460921272772299">"Faili"</string>
    <string name="storage_images" msgid="2055893015567979387">"Picha"</string>
    <string name="storage_videos" msgid="6117698226447251033">"Video"</string>
    <string name="storage_audio" msgid="5994664984472140386">"Sauti"</string>
    <string name="storage_apps" msgid="3564291603258795216">"Programu"</string>
    <string name="storage_documents_and_other" msgid="3293689243732236480">"Hati na nyingine"</string>
    <string name="storage_system" msgid="8472410119822911844">"Mfumo"</string>
    <string name="storage_trash" msgid="2807138998886084856">"Tupio"</string>
    <string name="storage_trash_dialog_title" msgid="2296169576049935200">"Je, ungependa kusafisha tupio?"</string>
    <string name="storage_trash_dialog_ask_message" msgid="8982602137242358798">"Kuna <xliff:g id="TOTAL">%1$s</xliff:g> za faili katika tupio. Vipengee vyote vitafutwa kabisa na hutaweza kuvirejesha."</string>
    <string name="storage_trash_dialog_empty_message" msgid="7334670765528691400">"Tupio halina chochote"</string>
    <string name="storage_trash_dialog_confirm" msgid="1707723334982760436">"Safisha tupio"</string>
    <string name="storage_usage_summary" msgid="4591121727356723463">"Umetumia <xliff:g id="UNIT">%2$s</xliff:g> <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
    <string name="storage_total_summary" msgid="7163360249534964272">"Jumla <xliff:g id="UNIT">%2$s</xliff:g><xliff:g id="NUMBER">%1$s</xliff:g>"</string>
    <string name="clear_instant_app_data" msgid="5951258323364386357">"Futa data kwenye programu"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Ungependa kuondoa programu hii inayofunguka papo hapo?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Fungua"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Michezo"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Nafasi iliyotumiwa"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(imeondolewa kwa mtumiaji <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(imezimwa kwa mtumiaji <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Huduma ya kujaza kiotomatiki"</string>
    <string name="default_autofill_app" msgid="372234803718251606">"Huduma chaguomsingi ya kujaza kiotomatiki"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Manenosiri"</string>
    <string name="credman_chosen_app_title" msgid="7735183808067729319">"Huduma inayopendelewa"</string>
    <string name="credman_credentials" msgid="2620352336624160642">"Huduma za ziada"</string>
    <string name="autofill_passwords_count" msgid="6359289285822955973">"{count,plural, =1{Nenosiri #}other{Manenosiri #}}"</string>
    <string name="autofill_keywords" msgid="8598763328489346438">"otomatiki, jaza, kujaza kiotomatiki, nenosiri"</string>
    <string name="credman_keywords" msgid="8305600680836806170">"data, ufunguo wa siri, nenosiri"</string>
    <string name="credman_autofill_keywords" msgid="701180623776848914">"kiotomatiki, jaza, jaza kiotomatiki, data, ufunguo wa siri, nenosiri"</string>
    <string name="credman_button_change" msgid="4072629639218503790">"Badilisha"</string>
    <string name="credman_button_open" msgid="7519871964170816850">"Fungua"</string>
    <string name="credman_app_list_preference_none" msgid="2509646651254971448">"Hujachagua yoyote"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&lt;b&gt;Hakikisha kuwa unaamini programu hii&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; hutumia kilicho kwenye skrini yako kubaini kinachoweza kujazwa kiotomatiki."</string>
    <string name="credman_autofill_confirmation_message" msgid="843829628024668466">"&lt;b&gt;Tumia &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt;?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Manenosiri mapya, funguo za siri na maelezo mengine yatahifadhiwa hapa kuanzia sasa. Huenda &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; ikatumia maudhui kwenye skrini yako kubaini kinachoweza kujazwa kiotomatiki."</string>
    <string name="credman_picker_title" msgid="8442086614222006564">"Huduma unayopendelea kwa manenosiri, funguo za siri na kujaza kiotomatiki"</string>
    <string name="credman_confirmation_message_title" msgid="8847900085593880729">"Ungependa kuzima %1$s?"</string>
    <string name="credman_confirmation_message" msgid="2357324543658635239">"&lt;b&gt;Ungependa kuzima huduma hii?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Maelezo yaliyohifadhiwa kama vile manenosiri, funguo za siri, njia za kulipa na maelezo mengine hayatajazwa utakapoingia katika akaunti. Ili utumie maelezo uliyohifadhi, chagua nenosiri, ufunguo wa siri au huduma ya data."</string>
    <string name="account_dashboard_title_with_passkeys" msgid="6214673787161409996">"Manenosiri, funguo za siri na kujaza kiotomatiki"</string>
    <string name="credman_confirmation_message_new_ui" msgid="6126274509951156460">"&lt;b&gt;Ungependa kuzima huduma zote?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Manenosiri, funguo za siri na maelezo mengine yaliyohifadhiwa hayatapatikana ili kujazwa kiotomatiki unapoingia katika akaunti"</string>
    <string name="credman_autofill_confirmation_message_new_ui" msgid="6222139222478822267">"&lt;b&gt;Badili huduma unayopendelea kuwa &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt;?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Manenosiri mapya, funguo za siri na maelezo mengine yatahifadhiwa hapa kuanzia sasa. Huenda &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; ikatumia maudhui kwenye skrini yako kubaini kinachoweza kujazwa kiotomatiki"</string>
    <string name="credman_enable_confirmation_message_title" msgid="1037501792652277829">"Ungependa kutumia %1$s?"</string>
    <string name="credman_confirmation_turn_off_positive_button" msgid="5678773011513369161">"Zima"</string>
    <string name="credman_confirmation_change_provider_positive_button" msgid="7732302992885116967">"Badilisha"</string>
    <string name="credman_limit_error_msg_title" msgid="1525814645803612135">"Unaweza kuwasha huduma 5 pekee"</string>
    <string name="credman_limit_error_msg" msgid="2521803280130310063">"Zima angalau huduma 1 ili uweze kuongeza nyingine"</string>
    <string name="credman_enable_confirmation_message" msgid="8407841892310870169">"%1$s hutumia maudhui kwenye skrini yako kubaini kinachoweza kujazwa kiotomatiki."</string>
    <string name="credman_error_message_title" msgid="4099557206946333568">"Manenosiri, funguo za siri na kikomo cha huduma za data"</string>
    <string name="credman_error_message" msgid="8334797097200415449">"Unaweza kutumia hadi manenosiri 5, funguo za siri na huduma za data zinazotumika kwa wakati mmoja. Zima huduma ili uweke zaidi."</string>
    <string name="credman_confirmation_message_positive_button" msgid="2812613187691345361">"Zima"</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Kujaza Kiotomatiki"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Kiwango cha kumbukumbu"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Idadi ya juu zaidi ya maombi kwa kila kipindi"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Idadi ya juu zaidi ya makundi ya data yanayoonekana"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Rejesha thamani chaguomsingi"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Imebadilisha chaguo za wasanidi programu za kujaza kiotomatiki"</string>
    <string name="location_category" msgid="3496759112306219062">"Mahali"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Kiashirio cha sehemu ya arifa"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Onyesha kwa maeneo yote, ikiwa ni pamoja na mtandao na muunganisho"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Lazimisha vipimo vya GNSS kamili"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Fuatilia mikusanyiko na mawimbi yote yasiyo na utendakazi wa GNSS"</string>
    <string name="input_method_category" msgid="2252659253631639005">"Mbinu ya Kuingiza Data"</string>
    <string name="stylus_handwriting" msgid="2154591374132794563">"Mwandiko wa stylus"</string>
    <string name="stylus_handwriting_summary" msgid="6333425895172696950">"Ikiwa imewashwa, Mbinu ya kuingiza data ya sasa hupokea stylus MotionEvent ikiwa Kihariri kimeangaziwa."</string>
    <string name="device_theme" msgid="5027604586494772471">"Mandhari ya kifaa"</string>
    <string name="default_theme" msgid="4815428567082263639">"Chaguomsingi"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Jina la mtandao"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Onyesha jina la mtandao kwenye sehemu ya arifa"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Programu inayofunguka papo hapo"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Ungependa kuzima kidhibiti cha hifadhi?"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Sasisha kipengele cha Usinisumbue"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Sitisha arifa ili uendelee kumakinika"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Kipengele hakipatikani"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Kipengele hiki kimezimwa kwa sababu kinapunguza kasi ya simu yako"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Onyesha kidirisha cha programu kuacha kufanya kazi kila wakati"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Onyesha kisanduku kila wakati programu inapoacha kufanya kazi"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Chagua programu inayoweza kutumia ANGLE"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Hujaweka programu yoyote inayoweza kutumia ANGLE"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"Programu inayoweza kutumia ANGLE: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Mapendeleo ya Kiendeshaji cha Michoro"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Badilisha mipangilio ya kiendeshaji cha michoro"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Wakati kuna viendeshaji vingi vya michoro, unaweza kuchagua kutumia kiendeshaji kilichosasishwa cha michoro kwa Programu zilizosakinishwa kwenye kifaa."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Washa katika programu zote"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Chagua Kiendeshaji cha Michoro"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Chaguomsingi"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Kiendeshaji cha Michezo"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Kiendeshaji cha Msanidi Programu"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Kiendeshaji cha Michoro cha Mfumo"</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">"Kipengele cha jaribio: Washa ANGLE"</string>
    <string name="enable_angle_as_system_driver_summary" msgid="2170215556348477481">"Onyo: Kitawasha ANGLE kama kiendeshaji chaguomsingi cha OpenGL ES. Kipengele hiki ni cha jaribio na huenda kisioane na baadhi ya programu za kamera na video."</string>
    <string name="reboot_dialog_enable_angle_as_system_driver" msgid="2619263039763150810">"Unahitaji kuwasha tena ili kubadilisha kiendeshaji cha mfumo cha OpenGL ES"</string>
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"Mabadiliko ya Uoanifu wa Programu"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Geuza mabadiliko ya uoanifu wa programu"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Mabadiliko chaguomsingi yaliyowashwa"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Mabadiliko chaguomsingi yaliyozimwa"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Mabadiliko ya uoanifu wa programu yanaweza tu kubadilishwa kwa ajili ya programu zinazoweza kutatuliwa. Sakinisha programu inayoweza kutatuliwa na ujaribu tena."</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Inategemea mipangilio mingine"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Akaunti"</string>
    <string name="my_device_info_account_preference_summary" msgid="3510582677937510545">"Akaunti %d"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Jina la kifaa"</string>
    <string name="my_device_info_basic_info_category_title" msgid="381963187269356548">"Maelezo ya msingi"</string>
    <string name="my_device_info_legal_category_title" msgid="7732792841537995127">"Sheria na kanuni"</string>
    <string name="my_device_info_device_details_category_title" msgid="4848438695638348680">"Maelezo ya kifaa"</string>
    <string name="my_device_info_device_identifiers_category_title" msgid="2197063484127704153">"Vitambulishi vya kifaa"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"Kudhibiti Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Ruhusu programu idhibiti Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Ruhusu programu hii iwashe au izime Wi-Fi, itafute na iunganishe kwenye mitandao ya Wi-Fi, iongeze au iondoe mitandao, au ianzishe mtandao pepe wa eneo mahususi"</string>
    <string name="change_nfc_tag_apps_title" msgid="91514009058149617">"Washa kupitia NFC"</string>
    <string name="change_nfc_tag_apps_detail_switch" msgid="240286205725043561">"Ruhusu programu kutumika wakati wa uchanganuzi wa NFC"</string>
    <string name="change_nfc_tag_apps_detail_summary" msgid="3338220223868942195">"Ruhusu programu hii ifunguke wakati tagi ya NFC inachanganuliwa.\nIkiwa ruhusa hii imewashwa, programu itapatikana kama chaguo wakati wowote tagi inapotambuliwa."</string>
    <string name="media_output_title" msgid="8283629315159510680">"Cheza muziki kwenye"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Cheza <xliff:g id="LABEL">%s</xliff:g> kwenye"</string>
    <string name="media_output_title_without_playing" msgid="3339321669132875821">"Itaendelea kucheza sauti"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"Kifaa hiki"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Haipatikani wakati unaongea kwa simu"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Pokea simu kwenye"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"Huwezi kubadilisha APN hii."</string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Zuia simu isilie"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Bonyeza vitufe vya Kuwasha na Kuongeza Sauti kwa pamoja ili"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Njia ya mkato ya kuzuia mlio"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Kutetema"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Kuzima"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Tetema"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Zima sauti"</string>
    <string name="prevent_ringing_option_unavailable_lpp_summary" msgid="8070356204398144241">"Ili uwashe, kwanza badilisha \"Kitufe cha kuwasha/kuzima cha kubonyeza na kushikilia\" kiwe menyu ya kuzima/kuwasha."</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Maelezo ya mtandao"</string>
    <string name="devices_title" msgid="649715719278562515">"Vifaa"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Chagua mtandao"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Haijaunganishwa"</string>
    <string name="network_connected" msgid="7637745547242487795">"Umeunganisha"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Inaunganisha…"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Imeshindwa kuunganisha"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"Hakuna mitandao iliyopatikana."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Imeshindwa kupata mitandao. Jaribu tena."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(hairuhusiwi)"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"Hakuna SIM"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Hamna"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Inahitaji SIM ili uunganishe"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Inahitaji SIM ya <xliff:g id="WIRELESS_CARRIER">%s</xliff:g> ili uunganishe"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Hali ya mtandao inayopendelewa: WCDMA pendekezwa"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Hali ya mtandao inayopendelewa: GSM pekee"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Hali ya mtandao inayopendelewa: WCDMA pekee"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Hali ya mtandao inayopendelewa: GSM / WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Hali ya mtandao inayopendelewa: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Hali ya mtandao inayopendelewa: CDMA / EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Hali ya mtandao inayopendelewa: CDMA pekee"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Hali ya mtandao inayopendelewa: EvDo pekee"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Hali ya mtandao inayopendelewa: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Hali ya mtandao inayopendelewa: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Hali ya mtandao inayopendelewa: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Hali ya mtandao inayopendelewa: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Hali ya mtandao inayopendelewa: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Hali ya mtandao inayopendelewa: Jumla"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Hali ya mtandao inayopendelewa: LTE / WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Hali ya mtandao inayopendelewa: LTE / GSM / UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Hali ya mtandao inayopendelewa: LTE / CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Hali ya mtandao inayopendelewa: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Hali ya mtandao inayopendelewa: TDSCDMA / WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Hali ya mtandao inayopendelewa: LTE / TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Hali ya mtandao inayopendelewa: TDSCDMA / GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Hali ya mtandao inayopendelewa: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Hali ya mtandao inayopendelewa: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Hali ya mtandao inayopendelewa: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Hali ya mtandao inayopendelewa: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Hali ya mtandao inayopendelewa: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Hali ya mtandao inayopendelewa: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Hali ya mtandao inayopendelewa: NR pekee"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Hali ya mtandao inayopendelewa: NR / LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Hali ya mtandao inayopendelewa: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Hali ya mtandao inayopendelewa: NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Hali ya mtandao inayopendelewa: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Hali ya mtandao inayopendelewa: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Hali ya mtandao inayopendelewa: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Hali ya mtandao inayopendelewa: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Hali ya mtandao inayopendelewa: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Hali ya mtandao inayopendelewa: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Hali ya mtandao inayopendelewa: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_5G_recommended" msgid="4769018972369031538">"5G (inapendekezwa)"</string>
    <string name="network_lte" msgid="2449425437381668780">"LTE (inapendekezwa)"</string>
    <string name="network_4G" msgid="9018841362928321047">"4G (inapendekezwa)"</string>
    <string name="select_automatically" msgid="2419752566747259155">"Chagua mtandao kiotomatiki"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Mipangilio ya mtoa huduma"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Weka huduma ya data"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Data ya mtandao wa simu"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Tumia data ya mtandao wa simu"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"Simu itabadili kiotomatiki itumie mtoa huduma huyu anapopatikana"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="9176513507571883986">"Hakuna SIM inayopatikana"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Mapendeleo ya simu"</string>
    <string name="sms_preference" msgid="7742964962568219351">"Mapendeleo ya SMS"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Iulize kila wakati"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Ongeza mtandao"</string>
    <string name="default_for_calls" msgid="2788950217176988034">"SIM chaguomsingi ya simu za sauti"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"SIM chaguomsingi ya SMS"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"SIM chaguomsingi ya simu za sauti na SMS"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"SIM chaguomsingi ya data ya mtandao"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Inatumia data ya mtandao wa simu"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Umezima data ya mtandao wa simu"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Inapatikana"</string>
    <string name="mobile_network_list_add_more" msgid="5076722903436552813">"Weka SIM"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Inatumika / SIM"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Haitumiki / SIM"</string>
    <string name="mobile_network_active_esim" msgid="3984452275968408382">"eSIM inayotumika"</string>
    <string name="mobile_network_inactive_esim" msgid="8777415108263057939">"eSIM haitumiki"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"Jina la SIM na rangi"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Jina"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Rangi (inatumiwa na programu zinazooana)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Hifadhi"</string>
    <string name="mobile_network_use_sim_on" msgid="5333182776279917886">"Tumia SIM hii"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Imezimwa"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="7182341033728911879">"Ili uzime SIM hii, ondoa SIM kadi"</string>
    <string name="mobile_network_tap_to_activate" msgid="5280456487243915465">"Gusa ili uwezeshe SIM yako ya <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="5387971155494245850">"Futa eSIM"</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Aina ya mtandao inayopendelewa"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Badilisha hali ya utendaji wa mtandao"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Aina ya mtandao inayopendelewa"</string>
    <string name="carrier_settings_version" msgid="3364919669057317776">"Toleo la mipangilio ya mtoa huduma"</string>
    <string name="call_category" msgid="641461844504128789">"Kupiga simu"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Kupiga simu ya video kupitia kampuni ya simu"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Chagua mfumo"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"Badilisha hali upigaji simu ukiwa nje ya mtandao wa kawaida kwa kutumia CDMA"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Chagua mfumo"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Mtandao"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"Usajili wa CDMA"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Badilisha kati ya RUIM/SIM na NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"usajili"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Usajili wa kiotomatiki…"</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Ungependa kuruhusu matumizi ya mitandao ya ng\'ambo?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Wasiliana na mtoa huduma za mtandao kwa maelezo kuhusu bei."</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"Hali ya Mtandao Isiyo sahihi <xliff:g id="NETWORKMODEID">%1$d</xliff:g>. Puuza"</string>
    <string name="satellite_setting_title" msgid="2543034229989047673">"Kutuma ujumbe kupitia setilaiti"</string>
    <string name="satellite_setting_enabled_summary" msgid="3554127722727530845">"Tuma na upokee ujumbe wa maandishi kupitia setilaiti. Imejumuishwa kwenye akaunti yako."</string>
    <string name="satellite_setting_disabled_summary" msgid="6789122487534159857">"Tuma na upokee ujumbe wa maandishi kupitia setilaiti. Haijumuishwi kwenye akaunti yako."</string>
    <string name="keywords_satellite_setting" msgid="3312183289776517695">"Kutuma ujumbe kupitia setilaiti"</string>
    <string name="category_name_about_satellite_messaging" msgid="3756205049485508340">"Kuhusu kutuma ujumbe kupitia setilaiti"</string>
    <string name="title_about_satellite_setting" msgid="9212860038048311345">"Unaweza kutuma na kupokea ujumbe wa maandishi kupitia setilaiti kama sehemu ya akaunti inayotimiza masharti ya <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="category_title_your_satellite_plan" msgid="3017895097366691841">"Mpango wako wa <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="title_have_satellite_plan" msgid="2048372355699977947">"Huduma ya kutuma ujumbe kupitia setilaiti imejumuishwa kwenye akaunti yako"</string>
    <string name="title_no_satellite_plan" msgid="2876056203035197505">"Huduma ya kutuma ujumbe kupitia setilaiti haijajumuishwa kwenye akaunti yako"</string>
    <string name="summary_add_satellite_setting" msgid="3815254731634052432">"Weka huduma ya kutuma ujumbe kupitia setilaiti"</string>
    <string name="category_name_how_it_works" msgid="585303230539269496">"Utaratibu wake"</string>
    <string name="title_satellite_connection_guide" msgid="3294802307913609072">"Ukiwa huna mtandao wa simu"</string>
    <string name="summary_satellite_connection_guide" msgid="3496123195218418456">"Simu yako itaunganisha kiotomatiki kwenye setilaiti. Kwa muunganisho bora, hakikisha anga inaonekana vizuri."</string>
    <string name="title_supported_service" msgid="4275535165812691571">"Baada ya simu yako kuunganisha kwenye setilaiti"</string>
    <string name="summary_supported_service" msgid="4320535903444834786">"Unaweza kumtumia yeyote ujumbe, ikiwa ni pamoja na huduma za dharura. Simu yako itaunganisha tena kwenye mtandao wa simu ukipatikana."</string>
    <string name="satellite_setting_summary_more_information" msgid="4008690241760925372">"Huduma ya kutuma ujumbe kupitia setilaiti inaweza kuchukua muda mrefu na inapatikana katika baadhi ya maeneo tu. Hali ya hewa na majengo fulani yanaweza kuathiri muunganisho wako wa setilaiti. Huduma ya kupiga simu kupitia setilaiti haipatikani.\n\nInaweza kuchukua muda kwa mabadiliko uliyofanya kwenye akaunti yako kuonekana katika Mipangilio. Wasiliana na <xliff:g id="CARRIER_NAME">%1$s</xliff:g> kwa maelezo."</string>
    <string name="more_about_satellite_messaging" msgid="3385673133561348509">"Maelezo zaidi kuhusu kutuma ujumbe wa setilaiti"</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Majina ya Milango ya Mtandao"</string>
    <string name="keywords_access_point_names" msgid="8174967126858505945">"apn"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Haipatikani inapounganishwa kwenye <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"Angalia zaidi"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"Ungependa kuwasha <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name" msgid="4842051610633654278">"Ungependa kuwasha SIM?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"Ungependa kubadili utumie <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"Ungependa kubadili ili utumie SIM kadi?"</string>
    <string name="sim_action_switch_sub_dialog_mep_title" msgid="933856847099933004">"Ungependa kutumia <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="7474905814976249607">"Unaweza kutumia SIM 1 pekee kwa wakati mmoja.\n\nHatua ya kubadilisha ili utumie huduma ya <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> haitakata huduma yako ya <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="6415848271400253954">"Unaweza kutumia eSIM 1 pekee kwa wakati mmoja.\n\nHatua ya kubadilisha ili utumie huduma ya <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> haitakata huduma yako ya <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="421658355882679837">"Unaweza kutumia SIM 1 pekee kwa wakati mmoja.\n\nHatua ya kubadilisha haitakata huduma yako ya <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_mep_text" msgid="8348764755143679582">"Unaweza kutumia SIM mbili kwa wakati mmoja. Ili utumie <xliff:g id="CARRIER_NAME">%1$s</xliff:g>, zima SIM nyingine."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Badili utumie <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">"Zima <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_info_outline_for_turning_off" msgid="1617619100229136888">"Kuzima SIM hakutaghairi huduma yako"</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="8144175623622669136">"Inawezesha SIM yako…"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="697127154780501304">"Inabadili ili kutumia <xliff:g id="CARRIER_NAME">%1$s</xliff:g>…"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="2718084141744769701">"Imeshindwa kubadilisha SIM"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="8332742656111984482">"Hitilafu fulani imetokea. Imeshindwa kubadilisha SIM."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"Ungependa kuzima <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"Ungependa kuzima SIM?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"Inazima SIM<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="1808735136395980905">"Imeshindwa kuzima SIM"</string>
    <string name="privileged_action_disable_fail_text" msgid="6236231745255527458">"Hitilafu fulani imetokea na SIM yako imeshindwa kuzimwa."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"Ungependa kutumia SIM 2?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"Kifaa hiki kinaweza kutumia SIM mbili kwa wakati mmoja. Ili uendelee kutumia SIM moja kwa wakati mmoja, gusa \"Hapana\"."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Ungependa kuzima kisha uwashe kifaa?"</string>
    <string name="sim_action_yes" msgid="8076556020131395515">"Ndiyo"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Zima kisha uwashe"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"Hapana"</string>
    <string name="sim_action_cancel" msgid="2668099867029610910">"Ghairi"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Badilisha"</string>
    <string name="sim_action_turn_off" msgid="3506698692916473000">"Zima"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"Imeshindwa kuanza kutumia SIM"</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Jaribu kuwasha SIM tena. Iwapo tatizo litaendelea, zima kisha uwashe kifaa chako."</string>
    <string name="sim_onboarding_bottomsheets_title" msgid="143711121394213711">"Weka mipangilio ya SIM yako"</string>
    <string name="sim_onboarding_bottomsheets_msg" msgid="7367245016476460849">"Weka mapendeleo yako ya mtandao wa simu ili utumie zaidi ya SIM moja kwenye kifaa hiki"</string>
    <string name="sim_onboarding_label_sim_title" msgid="273162565849288273">"Weka lebo za SIM zako"</string>
    <string name="sim_onboarding_label_sim_msg" msgid="5105859235219529056">"Utaona lebo hizi unapopiga simu, unapotuma SMS, unapotumia data na katika Mipangilio"</string>
    <string name="sim_onboarding_label_sim_dialog_title" msgid="5839073125605286120">"Lebo ya SIM"</string>
    <string name="sim_onboarding_label_sim_dialog_label" msgid="9020433985426525185">"Lebo"</string>
    <string name="sim_onboarding_select_sim_title" msgid="5895262188167744055">"Chagua SIM unazotaka kutumia"</string>
    <string name="sim_onboarding_select_sim_msg" msgid="5638859405391915048">"Unaweza kutumia SIM mbili kwa wakati mmoja"</string>
    <string name="sim_onboarding_primary_sim_title" msgid="2793090401371135675">"Weka SIM zako za msingi"</string>
    <string name="sim_onboarding_primary_sim_msg" msgid="5484656671490558032">"Chagua SIM ambazo ungependa kutumia kwa chaguomsingi kupiga simu, kutuma SMS na kwa muunganisho wa data"</string>
    <string name="primary_sim_title" msgid="2508161011657571566">"SIM zako za msingi"</string>
    <string name="primary_sim_calls_title" msgid="4961189133582615685">"Simu"</string>
    <string name="primary_sim_texts_title" msgid="1287584042733097749">"Ujumbe"</string>
    <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Kubadilisha muunganisho wa data kiotomatiki"</string>
    <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Tumia muunganisho wa data wa SIM yoyote kulingana na ufikiaji na upatikanaji"</string>
    <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Data pekee"</string>
    <string name="sim_onboarding_setup" msgid="5750393553605388463">"Weka mipangilio"</string>
    <string name="sim_onboarding_next" msgid="6415025179929475355">"Endelea"</string>
    <string name="sim_onboarding_progressbar_turning_sim_on" msgid="1163318788393361574">"Inawasha huduma ya <xliff:g id="CARRIER_NAME">%1$s</xliff:g>…"</string>
    <string name="mobile_network_spn_title" msgid="3053793174495329077">"Mtandao wa simu"</string>
    <string name="mobile_network_phone_number_title" msgid="2090794402855021784">"Namba ya simu"</string>
    <string name="mobile_network_sim_label_color_title" msgid="2401352348041132876">"Lebo na rangi ya SIM"</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Kuwasha mtandao"</string>
    <string name="sim_switch_channel_id" msgid="4927038626791837861">"Inabadilisha mtoa huduma"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="975447139749692794">"SIM yako ya <xliff:g id="CARRIER_NAME">%1$s</xliff:g> inatumika"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Gusa ili usasishe mipangilio ya SIM"</string>
    <string name="switch_to_removable_notification" msgid="7640342063449806296">"Sasa unatumia <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="switch_to_removable_notification_no_carrier_name" msgid="7384856964036215338">"Sasa unatumia mtoa huduma mwingine"</string>
    <string name="network_changed_notification_text" msgid="2407908598496951243">"Umebadilisha mtandao wako wa simu"</string>
    <string name="dsds_notification_after_suw_title" msgid="3738898232310273982">"Weka mipangilio ya SIM yako nyingine"</string>
    <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"Chagua SIM yako inayotumika sana au utumie SIM mbili wakati mmoja"</string>
    <string name="choose_sim_title" msgid="66509047151583877">"Chagua SIM ya kutumia"</string>
    <string name="choose_sim_text" msgid="8992163497852069924">"{count,plural, =1{SIM 1 inapatikana kwenye kifaa hiki, lakini unaweza kutumia moja tu kwa wakati mmoja}=2{SIM 2 zinapatikana kwenye kifaa hiki, lakini unaweza kutumia moja tu kwa wakati mmoja}other{SIM # zinapatikana kwenye kifaa hiki, lakini unaweza kutumia moja tu kwa wakati mmoja}}"</string>
    <string name="choose_sim_activating" msgid="6485547671356386998">"Tunawasha <xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="choose_sim_could_not_activate" msgid="866488735834045525">"Tumeshindwa kuwasha SIM hii kwa sasa"</string>
    <string name="switch_sim_dialog_title" msgid="5407316878973237773">"Ungependa kutumia <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="switch_sim_dialog_text" msgid="7530186862171635464">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> itatumika kwa ajili ya data ya mtandao wa simu, simu na SMS."</string>
    <string name="switch_sim_dialog_no_switch_title" msgid="809763410787744247">"Hakuna SIM zinazotumika zinazopatikana"</string>
    <string name="switch_sim_dialog_no_switch_text" msgid="7053939850026876088">"Ili utumie data ya mtandao wa simu, vipengele vya simu na SMS baadaye, nenda kwenye mipangilio ya mtandao wako"</string>
    <string name="sim_card_label" msgid="6263064316075963775">"SIM"</string>
    <string name="erase_sim_dialog_title" msgid="4742077437653028326">"Ungependa kufuta eSIM hii?"</string>
    <string name="erase_sim_dialog_text" msgid="1406141218170595272">"Hatua hii huondoa huduma ya <xliff:g id="CARRIER_NAME_A">%1$s</xliff:g> kwenye kifaa hiki, lakini mpango wako wa <xliff:g id="CARRIER_NAME_B">%1$s</xliff:g> hautakatwa."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Futa"</string>
    <string name="erasing_sim" msgid="4237180547590463930">"Kinafuta eSIM…"</string>
    <string name="erase_sim_fail_title" msgid="1445700500168357303">"Kimeshindwa kufuta eSIM"</string>
    <string name="erase_sim_fail_text" msgid="6898841004987411547">"Hitilafu fulani imetokea na eSIM hii haijafutwa.\n\nZima kisha uwashe kifaa chako na ujaribu tena."</string>
    <string name="wifi_warning_dialog_title" msgid="7328515476966592390">"Unganisha kwenye Wi‑Fi kabla ya kufuta"</string>
    <string name="wifi_warning_dialog_text" msgid="6584060137703953174">"Hatua hii inafanya iwe rahisi zaidi kutumia eSIM yako tena siku zijazo bila kuhitajika kuwasiliana na mtoa huduma wako"</string>
    <string name="wifi_warning_continue_button" msgid="8171574741789688214">"Futa licha ya hiyo"</string>
    <string name="wifi_warning_return_button" msgid="6226063181583906340">"Sawa"</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Unganisha kwenye kifaa"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"<xliff:g id="APPNAME">%1$s</xliff:g> yako inataka kutumia mtandao wa muda wa Wi‑Fi kuunganisha kwenye kifaa chako"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Hakuna vifaa vilivyopatikana. Hakikisha kuwa umewasha vifaa na vinaweza kuunganishwa."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Jaribu tena"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Hitilafu fulani imetokea. Programu imeghairi ombi la kuchagua kifaa."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Imeunganisha"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Imeshindwa kuunganisha"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Onyesha yote"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Inatafuta kifaa…"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Inaunganisha kwenye kifaa…"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Kushoto"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Kulia"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Kipochi"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Kidirisha cha Mipangilio"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Lazimisha hali ya eneo-kazi"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Lazimisha hali ya jaribio la eneo-kazi kwenye maonyesho yasiyo ya msingi"</string>
    <string name="enable_non_resizable_multi_window" msgid="6832903754625404477">"Ruhusu ukubwa usioweza kubadilishwa katika madirisha mengi"</string>
    <string name="enable_non_resizable_multi_window_summary" msgid="3275763753261901999">"Huruhusu programu zenye ukubwa usioweza kubadilishwa ziwe katika madirisha mengi"</string>
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Badilisha ulazimishaji wa mandhari meusi"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Hubatilisha mipangilio ya kipengele cha kulazimisha mandhari meusi ili kiwake kila wakati"</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Faragha"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Ruhusa, shughuli za akaunti, data ya binafsi"</string>
    <string name="privacy_controls_title" msgid="1383047169455206604">"Vidhibiti"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Ondoa"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Usiondoe"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"Je, ungependa kuondoa pendekezo hili?"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Nafasi ya hifadhi inakaribia kujaa. Umetumia <xliff:g id="PERCENTAGE">%1$s</xliff:g> - Imesalia <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Tuma maoni"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Je, ungependa kututumia maoni kuhusu pendekezo hili?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"Imenakili <xliff:g id="COPY_CONTENT">%1$s</xliff:g>kwenye ubao wa kunakili."</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Matumizi ya zana za walio na matatizo ya kuona au kusikia"</string>
    <string name="accessibility_usage_summary" msgid="4348285359995227813">"{count,plural, =1{Programu 1 ina idhini kamili ya kufikia kifaa chako}other{Programu # zina idhini kamili ya kufikia kifaa chako}}"</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Maelezo muhimu"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"ENDELEA"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"HAPANA"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Eneo"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="1417004513415772582">"Mtoa huduma wako anaweza kukusanya maelezo ya mahali ulipo unapotumia huduma hii kwa ajili ya simu za dharura.\n\nTembelea sera ya faragha ya mtoa huduma wako ili upate maelezo zaidi."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Huenda ukapoteza idhini ya kutumia muda au data inayosalia. Wasiliana na mtoa huduma wako kabla hujaondoa."</string>
    <string name="content_capture" msgid="868372905432812238">"Maudhui ya programu"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Ruhusu programu zitume maudhui kwenye mfumo wa Android"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Piga picha ya hifadhi ya mfumo"</string>
    <string name="development_memtag_page_title" msgid="3546667618748029188">"Kiendelezi cha Kuweka Lebo za Kumbukumbu"</string>
    <string name="development_memtag_intro" msgid="8032596625527637164">"Kiendelezi cha Kuweka Lebo za Kumbukumbu (MTE) hurahisisha kupata hitilafu za usalama wa kumbukumbu kwenye programu yako na kufanya msimbo wa ndani yake uwe salama zaidi."</string>
    <string name="development_memtag_footer" msgid="5681925148773626562">"Hatua ya kuwasha teknolojia ya MTE huenda ikasababisha utendaji wa kifaa kuwa wa polepole."</string>
    <string name="development_memtag_learn_more" msgid="8961984806973926704">"Pata maelezo zaidi kuhusu MTE"</string>
    <string name="development_memtag_toggle" msgid="2474420239518386894">"Washa MTE hadi utakapoizima"</string>
    <string name="development_memtag_reboot_message_on" msgid="8100075676107327847">"Utahitaji kuzima kisha uwashe kifaa chako ili uwashe MTE."</string>
    <string name="development_memtag_reboot_message_off" msgid="3703925647922079456">"Utahitaji kuzima kisha uwashe kifaa chako ili uzime MTE."</string>
    <string name="reboot_with_mte_title" msgid="2320125810211279">"Washa MTE kwa kipindi kimoja"</string>
    <string name="reboot_with_mte_message" msgid="1232881567956207641">"Mfumo utajizima kisha ujiwashe na kuruhusu kujaribu Kiendelezi cha Kuweka Lebo za Kumbukumbu (MTE). MTE inaweza kuathiri utendaji na uthabiti wa mfumo. Itawekwa upya utakapowasha tena kifaa chako."</string>
    <string name="reboot_with_mte_summary" msgid="3896537791216432882">"Zima kisha uwashe kwa kipindi kimoja MTE ikiwa imewashwa"</string>
    <string name="reboot_with_mte_already_enabled" msgid="4439168867613407167">"MTE tayari imewashwa"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Inapiga picha ya hifadhi ya mfumo"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Imeshindwa kupiga picha ya hifadhi ya mfumo"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Piga picha za hifadhi ya mfumo kiotomatiki"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Piga picha ya hifadhi ya Mfumo wa Android kiotomatiki inapotumia hifadhi kubwa mno"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Ondoa"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Simu za dharura"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"Mtoa huduma wako hakuruhusu kupiga simu za dharura kupitia Wi-Fi.\nKifaa hubadili kiotomatiki na kutumia mtandao wa simu ya mkononi ili kupiga simu ya dharura.\nUnaweza kupiga simu za dharura katika maeneo yaliyo na mtandao wa simu ya mkononi pekee."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Tumia Wi-Fi kupiga na kupokea simu ili kuboresha hali ya mawasiliano"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Ujumbe wa MMS unaoingia"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"Huwezi kutuma ujumbe wa MMS"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Gusa ili uruhusu ujumbe wa MMS kwenye <xliff:g id="OPERATOR_NAME">%1$s</xliff:g> wakati data ya mtandao wa simu imezimwa"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"Ujumbe wa MMS"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Tatizo limetokea wakati wa uunganishaji wa SIM"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Kutumia <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g> kunaweza kupunguza utendakazi. Gusa ili upate maelezo zaidi."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"Uunganishaji wa SIM"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Maelezo yako ya sera ya kazini"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Mipangilio inayodhibitiwa na msimamizi wako wa TEHAMA"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"GPU"</string>
    <string name="enable_16k_pages" msgid="5009476566957520607">"Kuwasha ukitumia ukurasa wa K 16"</string>
    <string name="enable_16k_pages_summary" msgid="428117226069445198">"Kuwasha kifaa ukitumia kiini cha ukurasa wa K 16"</string>
    <string name="confirm_enable_16k_pages_title" msgid="6751570067857011642">"Ungependa kuwasha tena ukitumia kiini kinachooana na kurasa za KB 16?"</string>
    <string name="confirm_enable_16k_pages_text" msgid="702888115148257215">"TAHADHARI: Huenda baadhi ya programu hazioani na hali hii. Kifaa kitajiwasha tena baada ya uthibitishaji."</string>
    <string name="confirm_enable_4k_pages_title" msgid="626987400420355263">"Ungependa kuwasha tena ukitumia kiini kinachooana na kurasa za KB 4?"</string>
    <string name="confirm_enable_4k_pages_text" msgid="6168921566226074524">"Kifaa kitajiwasha tena baada ya uthibitishaji."</string>
    <string name="toast_16k_update_failed_text" msgid="8888858987184345567">"Imeshindwa kusasisha kiini kiwe kinachooana na kurasa za KB 16."</string>
    <string name="progress_16k_ota_title" msgid="2117218313875523741">"Kutekeleza mabadiliko"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Kidhibiti cha ripoti ya hitilafu"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Hubaini programu inayodhibiti njia ya mkato ya Ripoti ya Hitilafu kwenye kifaa chako."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Binafsi"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Kazi"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Chaguomsingi la mfumo"</string>
    <string name="default_app_none" msgid="5420632042222036264">"Hamna"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"Chaguo hili halipo tena. Jaribu tena."</string>
    <string name="power_menu_setting_name" msgid="2394440932633137229">"Bonyeza na ushikilie kitufe cha kuwasha/kuzima"</string>
    <string name="power_menu_long_press_category_title" msgid="1051146091093775002">"Bonyeza na ushikilie kitufe cha kuwasha au kuzima ili ufikie"</string>
    <string name="power_menu_long_press_for_power_menu_title" msgid="477584639843663599">"Menyu ya kuzima au kuwasha"</string>
    <string name="power_menu_long_press_for_assistant_title" msgid="6557738348262616455">"Mratibu dijitali"</string>
    <string name="power_menu_summary_long_press_for_assistant" msgid="32706459458422952">"Fikia mratibu dijitali"</string>
    <string name="power_menu_summary_long_press_for_power_menu" msgid="7617247135239683710">"Fikia menyu ya kuzima/kuwasha"</string>
    <string name="lockscreen_privacy_not_secure" msgid="3251276389681975912">"Ili utumie, weka mbinu ya kufunga skrini kwanza"</string>
    <string name="power_menu_power_volume_up_hint" msgid="5619917593676125759">"Menyu ya kuzima/kuwasha:\nBonyeza kitufe cha kuwasha/kuzima na kitufe cha kuongeza sauti kwa wakati mmoja"</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="1169955014711158873">"Zuia mlio: \n Bonyeza kitufe cha sauti ili utumie njia ya mkato"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_title" msgid="1626808509158422185">"Muda wa kubonyeza na kushikilia"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_summary" msgid="7550610071666801935">"Rekebisha kiwango cha hisi kwa kuchagua muda wa kubonyeza na kushikilia kitufe cha kuwasha/kuzima"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_low_label" msgid="3430099983480845635">"Mfupi"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_high_label" msgid="2059686170350829156">"Mrefu"</string>
    <string name="lockscreen_privacy_wallet_setting_toggle" msgid="4188327143734192000">"Onyesha kipochi"</string>
    <string name="lockscreen_privacy_wallet_summary" msgid="3984851951621168573">"Ruhusu ufikiaji wa kipochi kutoka kwenye skrini iliyofungwa"</string>
    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle" msgid="1856477548806618829">"Onyesha kichanganuzi cha msimbo wa QR"</string>
    <string name="lockscreen_privacy_qr_code_scanner_summary" msgid="4577409244972250235">"Ruhusu ufikiaji wa kichanganuzi cha msimbo wa QR kwenye skrini iliyofungwa"</string>
    <string name="lockscreen_privacy_controls_setting_toggle" msgid="7445725343949588613">"Onyesha vidhibiti vya vifaa"</string>
    <string name="lockscreen_privacy_controls_summary" msgid="7522918441738915364">"Kwenye skrini iliyofungwa"</string>
    <string name="lockscreen_trivial_controls_setting_toggle" msgid="2174300719855112358">"Tumia vidhibiti vya kifaa"</string>
    <string name="lockscreen_trivial_disabled_controls_summary" msgid="7593626010580689155">"Ili utumie, washa kwanza \"Onyesha vidhibiti vya vifaa\""</string>
    <string name="lockscreen_double_line_clock_summary" msgid="4109235686687860393">"Ukubwa wa saa hubadilika kulingana na maudhui yaliyo kwenye skrini iliyofungwa"</string>
    <string name="lockscreen_double_line_clock_setting_toggle" msgid="802271087416091548">"Saa inayobadilika"</string>
    <string name="lockscreen_quick_affordances_title" msgid="8615741551327565793">"Njia za mkato"</string>
    <plurals name="lockscreen_quick_affordances_summary" formatted="false" msgid="4225396036524703997">
      <item quantity="other"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="one"><xliff:g id="FIRST_0">%1$s</xliff:g></item>
    </plurals>
    <string name="rtt_settings_title" msgid="7049259598645966354"></string>
    <string name="rtt_settings_no_visible" msgid="7440356831140948382"></string>
    <string name="rtt_settings_visible_during_call" msgid="7866181103286073700"></string>
    <string name="rtt_settings_always_visible" msgid="2364173070088756238"></string>
    <string name="volte_5G_limited_title" msgid="5908052268836750629">"Ungependa kuzima VoLTE?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"Hatua hii pia huzima muunganisho wako wa 5G.\nSimu ya sauti inapoendelea, huwezi kutumia intaneti na huenda baadhi ya programu zisifanye kazi."</string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Simamisha utekelezaji kwa programu zilizowekwa kwenye akiba"</string>
    <string name="blob_never_expires_text" msgid="7293376386620106623">"Muda wa matumizi hauna kikomo."</string>
    <string name="accessor_never_expires_text" msgid="4647624492147788340">"Muda wa kukodisha hauna kikomo."</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Ruhusu programu zinazowekelewa juu ya nyingine kwenye Mipangilio"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Ruhusu programu zinazoweza kuonyeshwa juu ya programu nyingine ziwekelewe juu ya skrini za Mipangilio"</string>
    <string name="allow_mock_modem" msgid="3832264806530479214">"Ruhusu Modemu ya Majaribio"</string>
    <string name="allow_mock_modem_summary" msgid="9097416612748005374">"Ruhusu kifaa hiki kiendeshe huduma ya Modemu ya Majaribio kwa ajili ya majaribio ya vifaa. Usiwezeshe kipengele hiki wakati wa matumizi ya kawaida ya simu"</string>
    <string name="disable_screen_share_protections_for_apps_and_notifications" msgid="4987116103699222633">"Zima mipangilio ya ulinzi wa kuruhusu skrini ifikiwe"</string>
    <string name="disable_screen_share_protections_for_apps_and_notifications_summary" msgid="932295234626582052">"Huzima vipengele vya ulinzi wa arifa na programu ambazo mfumo hutumia wakati wa kuruhusu ufikiaji wa skrini"</string>
    <string name="media_controls_title" msgid="403271085636252597">"Maudhui"</string>
    <string name="media_controls_resume_title" msgid="855076860336652370">"Bandika kicheza faili za sauti na video"</string>
    <string name="media_controls_resume_description" msgid="3163482266454802097">"Ili uendelee kucheza kwa haraka, kicheza faili za sauti na video hubaki kikiwa kimefunguliwa kila wakati katika Mipangilio ya Haraka"</string>
    <string name="media_controls_lockscreen_title" msgid="2188311721857512510">"Onyesha maudhui kwenye skrini iliyofungwa"</string>
    <string name="media_controls_lockscreen_description" msgid="3320333660404439510">"Ili uendelee kucheza maudhui kwa haraka, kicheza faili za sauti na video hubaki kikiwa kimefunguliwa kwenye skrini iliyofungwa"</string>
    <string name="media_controls_recommendations_title" msgid="3012692549413927608">"Onyesha mapendekezo ya maudhui ya programu ya Mratibu"</string>
    <string name="media_controls_recommendations_description" msgid="7596498733126824030">"Kulingana na shughuli zako"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Ficha kichezaji"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Onyesha kichezaji"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"maudhui"</string>
    <string name="camera_extensions_fallback_title" msgid="3604579046777004989">"Ruhusu viendelezi vya programu ya kamera"</string>
    <string name="camera_extensions_fallback_description" msgid="6939818294458854536">"Hali hii huwezesha utekelezaji chaguomsingi wa programu ya vipengele vya kina vya kamera, kama vile utengenezaji video Bila Kuangalia."</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"Bluetooth itawaka"</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"Intaneti"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"SIM"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Simu na SMS"</string>
    <string name="calls_and_sms_category" msgid="3788238090898237767">"Kupiga simu kupitia Wi-Fi"</string>
    <string name="calls_sms_wfc_summary" msgid="3940529919408667336">"Piga na upokee simu kupitia Wi‑Fi"</string>
    <string name="calls_preference_title" msgid="7536882032182563800">"Simu"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"SMS"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"mtoa huduma unayempendelea"</string>
    <string name="calls_sms_calls_preferred" msgid="9004261125829377885">"inapendekezwa kwa ajili ya simu"</string>
    <string name="calls_sms_sms_preferred" msgid="3855778890660922711">"inapendekezwa kwa ajili ya SMS"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"haipatikani"</string>
    <string name="calls_sms_temp_unavailable" msgid="8602291749338757424">"Haipatikani kwa muda"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"Hakuna SIM"</string>
    <string name="network_and_internet_preferences_title" msgid="8635896466814033405">"Mapendeleo ya mtandao"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"muunganisho wa mtandao, intaneti, isiyotumia waya, data, wifi, wi-fi, wi fi, mtandao wa simu, vifaa vya mkononi, mtoa huduma za vifaa vya mkononi, 4g, 3g, 2g, lte"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Ungependa kubadilisha mipangilio yako ya intaneti?"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Inabadilisha mipangilio yako ya intaneti…"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Rekebisha hitilafu ya muunganisho"</string>
    <string name="networks_available" msgid="3299512933684383474">"Mitandao inapatikana"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Ili kubadili mitandao, tenganisha ethaneti"</string>
    <string name="carrier_wifi_offload_title" msgid="7263365988016247722">"Miunganisho ya W+"</string>
    <string name="carrier_wifi_offload_summary" msgid="2980563718888371142">"Ruhusu Google Fi itumie mitandao ya W+ ili kuboresha kasi na upatikanaji wa mtandao"</string>
    <string name="carrier_wifi_network_title" msgid="5461382943873831770">"Mtandao wa W+"</string>
    <string name="sim_category_title" msgid="2341314000964710495">"SIM"</string>
    <string name="downloaded_sim_category_title" msgid="2876988650413179752">"eSIM"</string>
    <string name="downloaded_sims_category_title" msgid="487799905978489922">"eSIM"</string>
    <string name="sim_category_active_sim" msgid="3077009911935592178">"Imewashwa"</string>
    <string name="sim_category_inactive_sim" msgid="7351553344148400450">"Imezimwa"</string>
    <string name="sim_category_default_active_sim" msgid="1208194173387987231">" / Chaguomsingi ya <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="default_active_sim_calls" msgid="2390973682556353558">"simu"</string>
    <string name="default_active_sim_sms" msgid="8041498593025994921">"SMS"</string>
    <string name="default_active_sim_mobile_data" msgid="6798083892814045301">"data ya mtandao wa simu"</string>
    <string name="wifi_scan_notify_message" msgid="1331238142061476869">"Ili kuboreshe hali ya matumizi ya kifaa, programu na huduma zinaweza kutafuta mitandao ya Wi‑Fi wakati wowote, hata wakati umezima Wi‑Fi. Hali hii inaweza kutumika, kwa mfano, kuboresha huduma na vipengele vinavyohusiana na mahali. Unaweza kubadilisha mipangilio hii katika mipangilio ya kutafuta Wi-Fi."</string>
    <string name="wifi_scan_change" msgid="8438320311511852918">"Badilisha"</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">"Imeunganishwa"</string>
    <string name="mobile_data_temp_connection_active" msgid="3430470299756236413">"Imeunganishwa kwa muda"</string>
    <string name="mobile_data_temp_using" msgid="5211002380149434155">"Inatumia <xliff:g id="SUBNAME">%1$s</xliff:g> kwa muda"</string>
    <string name="mobile_data_no_connection" msgid="905897142426974030">"Hakuna muunganisho"</string>
    <string name="mobile_data_off_summary" msgid="1884248776904165539">"Data ya simu haitaunganishwa kiotomatiki"</string>
    <string name="mobile_data_disable_title" msgid="8438714772256088913">"Ungependa kuzima data ya mtandao wa simu?"</string>
    <string name="mobile_data_disable_message" msgid="7829414836454769970">"Hutaweza kufikia data au intaneti kupitia <xliff:g id="CARRIER">%s</xliff:g>. Intaneti itapatikana kupitia Wi-Fi pekee."</string>
    <string name="mobile_data_disable_message_default_carrier" msgid="4449469407705838612">"mtoa huduma wako"</string>
    <string name="not_allowed_by_ent" msgid="1958611623122304411">"Shirika lako haliruhusu"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Haipatikani kwa sababu umewasha hali ya wakati umelala"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Imemaliza kubadilisha mipangilio ya umuhimu wa arifa."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Programu"</string>
    <string name="bluetooth_message_access_notification_content" msgid="5111712860712823893">"Kifaa kinataka kufikia ujumbe wako. Gusa ili upate maelezo."</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Ungependa kuruhusu kifaa kifikie ujumbe?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="7186694737578788487">"Kifaa chenye Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, kinataka kufikia ujumbe wako.\n\nHujawahi kuunganisha kwenye <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="9175220052703433637">"Kifaa kinataka kufikia anwani na kumbukumbu za simu. Gusa ili upate maelezo."</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Ungependa kuruhusu kifaa kifikie anwani na kumbukumbu za simu?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"Kifaa chenye Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, kinataka kufikia anwani na kumbukumbu za simu. Hii ni pamoja na data kuhusu simu unazopigiwa na unazopiga.\n\nHujawahi kuunganisha kwenye <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Ung\'aavu"</string>
    <string name="category_name_lock_display" msgid="8310402558217129670">"Skrini iliyofungwa"</string>
    <string name="category_name_appearance" msgid="8287486771764166805">"Mwonekano"</string>
    <string name="category_name_color" msgid="937514550918977151">"Rangi"</string>
    <string name="category_name_display_controls" msgid="7046581691184725216">"Vidhibiti vingine vya skrini"</string>
    <string name="category_name_general" msgid="7737273712848115886">"Jumla"</string>
    <string name="dark_theme_main_switch_title" msgid="4045147031947562280">"Tumia Mandhari meusi"</string>
    <string name="bluetooth_main_switch_title" msgid="8409835540311309632">"Tumia Bluetooth"</string>
    <string name="prevent_ringing_main_switch_title" msgid="4726252811262086643">"Tumia kipengele cha kuzuia mlio"</string>
    <string name="use_wifi_hotsopt_main_switch_title" msgid="3909731167290690539">"Tumia mtandaopepe wa Wi-Fi"</string>
    <string name="app_pinning_main_switch_title" msgid="5465506660064032876">"Tumia kipengele cha kubandika programu"</string>
    <string name="developer_options_main_switch_title" msgid="1720074589554152501">"Tumia chaguo za wasanidi programu"</string>
    <string name="default_print_service_main_switch_title" msgid="4697133737128324036">"Tumia huduma ya kuchapisha"</string>
    <string name="multiple_users_main_switch_title" msgid="6686858308083037810">"Ruhusu watumiaji wengi"</string>
    <string name="multiple_users_main_switch_keywords" msgid="4845954458094134356">"ruhusu, kadhaa, mtumiaji, idhinisha, wengi"</string>
    <string name="wireless_debugging_main_switch_title" msgid="8463499572781441719">"Tumia kipengele cha utatuzi usiotumia waya"</string>
    <string name="graphics_driver_main_switch_title" msgid="6125172901855813790">"Tumia mapendeleo ya kiendeshaji cha michoro"</string>
    <string name="night_light_main_switch_title" msgid="3428298022467805219">"Tumia Mwanga wa Usiku"</string>
    <string name="nfc_main_switch_title" msgid="6295839988954817432">"Tumia NFC"</string>
    <string name="adaptive_brightness_main_switch_title" msgid="2681666805191642737">"Tumia mwangaza unaojirekebisha"</string>
    <string name="wifi_calling_main_switch_title" msgid="4070224008346815634">"Tumia kipengele cha kupiga simu kupitia Wi-Fi"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Angalia programu zote"</string>
    <string name="smart_forwarding_title" msgid="8368634861971949799">"Usambazaji Mahiri"</string>
    <string name="smart_forwarding_summary_enabled" msgid="3341062878373185604">"Umewasha kipengele cha Usambazaji Mahiri"</string>
    <string name="smart_forwarding_summary_disabled" msgid="5033880700091914809">"Umezima kipengele cha Usambazaji Mahiri"</string>
    <string name="smart_forwarding_ongoing_title" msgid="962226849074401228">"Mipangilio ya Simu"</string>
    <string name="smart_forwarding_ongoing_text" msgid="2189209372407117114">"Inasasisha Mipangilio…"</string>
    <string name="smart_forwarding_failed_title" msgid="1859891191023516080">"Hitilafu ya Mipangilio ya Simu"</string>
    <string name="smart_forwarding_failed_text" msgid="8682640643264071789">"Hitilafu ya SIM au mtandao."</string>
    <string name="smart_forwarding_failed_not_activated_text" msgid="997396203001257904">"SIM haijaanza kutumika."</string>
    <string name="smart_forwarding_input_mdn_title" msgid="5105463748849841763">"Weka Nambari za simu"</string>
    <string name="smart_forwarding_input_mdn_dialog_title" msgid="7542216086697868415">"Weka Nambari ya simu"</string>
    <string name="smart_forwarding_missing_mdn_text" msgid="2907314684242542226">"Nambari ya simu haipo."</string>
    <string name="smart_forwarding_missing_alert_dialog_text" msgid="7870419247987316112">"Sawa"</string>
    <string name="enable_2g_title" msgid="8184757884636162942">"Ruhusu 2G"</string>
    <string name="enable_2g_summary" msgid="2794534052372565914">"2G haina usalama wa kutosha, ila inaweza kuboresha muunganisho wako katika baadhi ya maeneo. Kwa simu za dharura, 2G inaruhusiwa kila wakati."</string>
    <string name="enable_2g_summary_disabled_carrier" msgid="8141118453219482762">"<xliff:g id="CARRIER_NAME_2G">%1$s</xliff:g> inahitaji 2G ipatikane"</string>
    <string name="require_cellular_encryption_title" msgid="7516008146269371585">"Inahitaji mbinu ya usimbaji fiche?"</string>
    <string name="require_cellular_encryption_summary" msgid="4813823321032908641">"Mbinu ya usimbaji fiche ni salama zaidi, lakini hutaweza kuunganisha katika baadhi ya maeneo. Kwa simu za dharura, mbinu ya usimbaji fiche haihitajiki kamwe"</string>
    <string name="app_info_all_services_label" msgid="1487070364839071105">"Huduma zote"</string>
    <string name="show_clip_access_notification" msgid="7782300987639778542">"Onyesha ufikiaji wa ubao wa kunakili"</string>
    <string name="show_clip_access_notification_summary" msgid="474090757777203207">"Onyesha ujumbe programu zinapofikia maandishi, picha au maudhui mengine uliyonakili"</string>
    <string name="all_apps" msgid="3054120149509114789">"Programu zote"</string>
    <string name="request_manage_bluetooth_permission_dont_allow" msgid="8798061333407581300">"Usiruhusu"</string>
    <string name="uwb_settings_title" msgid="8578498712312002231">"Bendi Pana Zaidi (UWB)"</string>
    <string name="uwb_settings_summary" msgid="3074271396764672268">"Inasaidia kutambua mahali vilipo vifaa vyenye Bendi Pana Zaidi (UWB) vilivyo karibu"</string>
    <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Zima hali ya ndegeni ili utumie Bendi Pana Zaidi"</string>
    <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB haipatikani katika mahali pa sasa"</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">"Ufikiaji wa kamera"</string>
    <string name="mic_toggle_title" msgid="265145278323852547">"Ufikiaji wa maikrofoni"</string>
    <string name="perm_toggle_description" msgid="5754629581767319022">"Kwa ajili ya programu na huduma"</string>
    <string name="mic_toggle_description" msgid="484139688645092237">"Kwenye programu na huduma. Mipangilio hii ikizimwa, huenda bado data ya maikrofoni ikashirikiwa unapopigia namba ya dharura."</string>
    <string name="previous_page_content_description" msgid="6438292457923282991">"Uliotangulia"</string>
    <string name="next_page_content_description" msgid="1641835099813416294">"Unaofuata"</string>
    <string name="colors_viewpager_content_description" msgid="2591751086138259565">"Onyesho la kukagua rangi"</string>
    <string name="bluetooth_sim_card_access_notification_title" msgid="7351015416346359536">"Ombi la ruhusa ya kufikia SIM"</string>
    <string name="bluetooth_sim_card_access_notification_content" msgid="8685623260103018309">"Kifaa kinataka kufikia SIM yako. Gusa ili upate maelezo."</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="5616323725563125179">"Ungependa kuruhusu ufikiaji wa SIM?"</string>
    <string name="bluetooth_sim_card_access_dialog_content" msgid="6281997628405909566">"Kifaa chenye Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, kinataka kufikia data iliyo kwenye SIM yako. Hii ni pamoja na anwani zako.\n\nKinapokuwa kimeunganishwa, <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> kitapokea simu zote zinazopigwa kwenye <xliff:g id="PHONE_NUMBER">%3$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_notification_title" msgid="2573547043170883947">"Kifaa chenye Bluetooth kinapatikana"</string>
    <string name="bluetooth_connect_access_notification_content" msgid="1328465545685433304">"Kifaa kinataka kuunganisha. Gusa ili upate maelezo."</string>
    <string name="bluetooth_connect_access_dialog_title" msgid="1948056782712451381">"Ungependa kuunganisha kwenye kifaa chenye Bluetooth?"</string>
    <string name="bluetooth_connect_access_dialog_content" msgid="4336436466468405850">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> kinataka kuunganishwa kwenye simu hii.\n\nHujawahi kuunganisha kwenye <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_dialog_negative" msgid="4944672755226375059">"Usiunganishe"</string>
    <string name="bluetooth_connect_access_dialog_positive" msgid="3630561675207269710">"Unganisha"</string>
    <string name="tare_settings" msgid="3788654800004869077">"Mipangilio ya TARE"</string>
    <string name="tare_on" msgid="2386073225978684535">"Washa"</string>
    <string name="tare_off" msgid="6305694402929756726">"Zima"</string>
    <string name="tare_revert" msgid="3855325741125236638">"Rejesha Mipangilio Chaguomsingi"</string>
    <string name="tare_settings_reverted_toast" msgid="8189887409285176731">"Umerejesha mipangilio chaguomsingi."</string>
    <string name="tare_max_satiated_balance" msgid="3914973999573150340">"Salio la Juu Wakati Kifaa Kimejaa Chaji"</string>
    <string name="tare_balances" msgid="731881382594747961">"Salio"</string>
    <string name="tare_consumption_limits" msgid="3230949387874396382">"Kikomo cha Matumizi"</string>
    <string name="tare_initial_consumption_limit" msgid="2921646306374048384">"Kikomo cha Matumizi ya Mwanzo"</string>
    <string name="tare_min_consumption_limit" msgid="3293145670921755789">"Kikomo cha chini cha Matumizi"</string>
    <string name="tare_max_consumption_limit" msgid="8335700580111808823">"Kikomo cha Juu zaidi cha Matumizi"</string>
    <string name="tare_modifiers" msgid="8919975635360280820">"Virekebishi"</string>
    <string name="tare_actions_ctp" msgid="5110104015354916401">"Vitendo (Gharama ya Kuzalisha Bidhaa)"</string>
    <string name="tare_actions_base_price" msgid="3300967942666376589">"Vitendo (Bei ya Msingi)"</string>
    <string name="tare_rewards_instantaneous" msgid="8358683519945340874">"Zawadi kwa kila tukio"</string>
    <string name="tare_rewards_ongoing" msgid="7657030286658143416">"Zawadi kwa kila sekunde ya muda wa tukio"</string>
    <string name="tare_rewards_max" msgid="5283055625642837010">"Idadi ya Juu ya Zawadi kwa Siku"</string>
    <string name="tare_app_install" msgid="7955806910408116882">"Usakinishaji wa Programu"</string>
    <string name="tare_top_activity" msgid="7266560655483385757">"Shughuli Maarufu"</string>
    <string name="tare_notification_seen" msgid="7829963536020087742">"Ameona Arifa"</string>
    <string name="tare_notification_seen_15_min" msgid="832174185809497764">"Mtumiaji Aliona Arifa Ndani ya Dakika 15"</string>
    <string name="tare_notification_interaction" msgid="3806204222322830129">"Matumizi ya Arifa"</string>
    <string name="tare_widget_interaction" msgid="2260701564089214184">"Matumizi ya Wijeti"</string>
    <string name="tare_other_interaction" msgid="8069163421115212751">"Matumizi Mengine ya Mtumiaji"</string>
    <string name="tare_job_max_start" msgid="1586399578665940836">"Kuanzisha Kazi ya Kipaumbele cha Juu Zaidi"</string>
    <string name="tare_job_max_running" msgid="2897217372986518495">"Kufanya Kazi ya Kipaumbele cha Juu Zaidi"</string>
    <string name="tare_job_high_start" msgid="7464143754932031022">"Kuanzisha Kazi ya Kipaumbele cha Juu"</string>
    <string name="tare_job_high_running" msgid="6541171046405088669">"Kufanya Kazi ya Kipaumbele cha Juu"</string>
    <string name="tare_job_default_start" msgid="6744427210148953151">"Kuanzisha Kazi Chaguomsingi"</string>
    <string name="tare_job_default_running" msgid="8429081804128945217">"Kufanya Kazi Chaguomsingi"</string>
    <string name="tare_job_low_start" msgid="4605440035856891746">"Kuanzisha Kazi ya Kipaumbele cha Chini"</string>
    <string name="tare_job_low_running" msgid="831668616902849604">"Kufanya Kazi ya Kipaumbele cha Chini"</string>
    <string name="tare_job_min_start" msgid="6508233901992538188">"Kuanzisha Kazi ya Kipaumbele cha Chini Zaidi"</string>
    <string name="tare_job_min_running" msgid="6167128996320622604">"Kufanya Kazi ya Kipaumbele cha Chini Zaidi"</string>
    <string name="tare_job_timeout_penalty" msgid="7644332836795492506">"Adhabu ya Kuchelewesha Kazi"</string>
    <string name="tare_min_balance_exempted" msgid="6693710075762973485">"Salio la Chini Wakati Kifaa Kimejaa Chaji (Kimeruhusiwa kutofuata kanuni)"</string>
    <string name="tare_min_balance_headless_app" msgid="6906353766678577244">"Salio la Chini Wakati Kifaa Kimejaa Chaji (Programu ya mfumo isiyo na kiolesura)"</string>
    <string name="tare_min_balance_other_app" msgid="3404774196832506476">"Salio la Chini Wakati Kifaa Kimejaa Chaji (Programu Zilizosalia)"</string>
    <string name="tare_min_balance_addition_app_updater" msgid="5391956072471201269">"Ongezeko la Salio la Chini Wakati Kifaa Kimejaa Chaji (Visasishaji vya Programu)"</string>
  <string-array name="tare_modifiers_subfactors">
    <item msgid="3325940509857535498">"Inachaji"</item>
    <item msgid="658627268149681677">"Sinzia"</item>
    <item msgid="1599558140284643834">"Hali ya Kiokoa Betri"</item>
    <item msgid="588427840913221601">"Hali ya Kuchakata"</item>
  </string-array>
    <string name="tare_dialog_confirm_button_title" msgid="9179397559760203348">"Thibitisha"</string>
    <string name="dream_preview_button_title" msgid="6637456541851795952">"Onyesho la kukagua"</string>
    <string name="dream_picker_category" msgid="7726447836872744867">"Chagua taswira ya skrini"</string>
    <string name="dream_complications_toggle_title" msgid="4273232303027449163">"Onyesha maelezo ya ziada"</string>
    <string name="dream_complications_toggle_summary" msgid="8088911054987524904">"Onyesha vitu kama vile, muda, hali ya hewa au taarifa zingine kwenye taswira ya skrini"</string>
    <string name="dream_home_controls_toggle_title" msgid="706799741564479248">"Onyesha vidhibiti vya vifaa nyumbani"</string>
    <string name="dream_home_controls_toggle_summary" msgid="4102519907917430579">"Onyesha vidhibiti vya vifaa nyumbani kwenye taswira ya skrini"</string>
    <string name="dream_more_settings_category" msgid="3119192146760773748">"Mipangilio zaidi"</string>
    <string name="dream_setup_title" msgid="2458303874255396142">"Chagua taswira ya skrini yako"</string>
    <string name="dream_setup_description" msgid="7508547154038580296">"Chagua utakachokiona kwenye skrini wakati kompyuta kibao yako imeshikiliwa kwenye kiweko. Kifaa chako kinaweza kutumia nishati nyingi zaidi taswira ya skrini inapotumika."</string>
    <string name="customize_button_title" msgid="1110284655990203359">"Badilisha upendavyo"</string>
    <string name="customize_button_description" msgid="7440248477266126231">"Uweke mapendeleo ya <xliff:g id="SCREENSAVER_NAME">%1$s</xliff:g>"</string>
    <string name="reboot_dialog_enable_freeform_support" msgid="6412591361284929149">"Itahitaji kuwashwa tena ili kuruhusu uwezo wa muundo huru."</string>
    <string name="reboot_dialog_force_desktop_mode" msgid="2021839270403432948">"Itahitaji kuwashwa tena ili kuwezesha hali ya kompyuta ya mezani kwenye skrini nyingine."</string>
    <string name="reboot_dialog_reboot_now" msgid="235616015988522355">"Washa tena sasa"</string>
    <string name="reboot_dialog_reboot_later" msgid="4261717094186904568">"Washa tena baadaye"</string>
    <string name="bluetooth_details_spatial_audio_title" msgid="1368071116994002707">"Sauti Inayojirekebisha"</string>
    <string name="bluetooth_details_spatial_audio_summary" msgid="5026859623681482668">"Sauti kutoka kwenye maudhui yanayooana huwa murua zaidi"</string>
    <string name="bluetooth_details_head_tracking_title" msgid="5416972521040337799">"Ufuatiliaji wa kichwa"</string>
    <string name="bluetooth_details_head_tracking_summary" msgid="3942238746595985395">"Sauti hubadilika kadiri unavyosogeza kichwa chako ili isikike kuwa ya asili zaidi"</string>
    <string name="bluetooth_details_permissions_sync_title" msgid="7277580382321003521">"Sawazisha ruhusa kutoka kwenye simu"</string>
    <string name="bluetooth_details_permissions_sync_summary" msgid="8125037984381432059">"Ipe saa yako ruhusa za programu ambazo umeruhusu kwenye simu hii"</string>
    <string name="bluetooth_details_audio_device_types_title" msgid="3381941189346781614">"Aina ya Kifaa cha Sauti"</string>
    <string name="bluetooth_details_audio_device_type_unknown" msgid="839337391037998014">"Haijulikani"</string>
    <string name="bluetooth_details_audio_device_type_speaker" msgid="3706227767994792124">"Spika"</string>
    <string name="bluetooth_details_audio_device_type_headphones" msgid="7644588291215033798">"Vipokea sauti vya kichwani"</string>
    <string name="bluetooth_details_audio_device_type_hearing_aid" msgid="1310631131071939859">"Visaidizi vya Kusikia"</string>
    <string name="bluetooth_details_audio_device_type_carkit" msgid="4439017600454703229">"Kifaa cha Gari"</string>
    <string name="bluetooth_details_audio_device_type_other" msgid="7019481234617207563">"Mengineyo"</string>
    <string name="ingress_rate_limit_title" msgid="2106694002836274350">"Kiwango cha kikomo cha upakuaji wa mtandao"</string>
    <string name="ingress_rate_limit_summary" msgid="1097811019742438371">"Weka mipangilio ya kiwango cha kikomo cha uingiaji kipimo data cha mtandao ambacho kinatumika katika mitandao yote inayotoa muunganisho wa intaneti."</string>
    <string name="ingress_rate_limit_dialog_title" msgid="5359461052422633789">"Weka mipangilio ya kiwango cha kikomo cha upakuaji wa mtandao"</string>
    <string name="ingress_rate_limit_no_limit_entry" msgid="8741098826008012163">"Hakuna kikomo"</string>
    <string name="disable_phantom_process_monitor_title" msgid="8348108346706188771">"Zima vizuizi vya mchakato tegemezi"</string>
    <string name="disable_phantom_process_monitor_summary" msgid="3044464635550256985">"Zima vizuizi kwenye utumiaji wa rasilimali za mfumo wa michakato tegemezi ya programu"</string>
    <string name="enable_notes_role_title" msgid="7662702013496114763">"Lazimisha kipengele cha Madokezo kiwashwe"</string>
    <string name="enable_notes_role_summary" msgid="5495721409392395089">"Washa ujumuishaji wa mfumo wa kuandika madokezo kupitia kipengele cha Madokezo. Ikiwa tayari umewasha kipengele cha Madokezo na hakitekelezi chochote. Unahitaji kuwasha tena."</string>
    <string name="bluetooth_broadcast_dialog_title" msgid="9172775308463135884">"Tangazo"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_app" msgid="1016617579194329005">"Arifu kwenye <xliff:g id="CURRENTAPP">%1$s</xliff:g>"</string>
    <string name="bluetooth_broadcast_dialog_find_message" msgid="6621660851669953883">"Sikiliza matangazo yanayochezwa karibu nawe"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_message" msgid="6198264676009094495">"Tangaza maudhui kwenye vifaa vilivyo karibu nawe au usikilize tangazo la mtu mwingine"</string>
    <string name="bluetooth_find_broadcast_title" msgid="5385985218699831970">"Matangazo"</string>
    <string name="bluetooth_find_broadcast_summary" msgid="3907899428626210673">"Unasikiliza"</string>
    <string name="bluetooth_find_broadcast" msgid="1768337775649457586">"Tafuta matangazo"</string>
    <string name="bluetooth_find_broadcast_button_leave" msgid="7881206581147104908">"Ondoa tangazo"</string>
    <string name="bluetooth_find_broadcast_button_scan" msgid="3995664694641895189">"Changanua msimbo wa QR"</string>
    <string name="find_broadcast_password_dialog_title" msgid="3176988702535737484">"Weka nenosiri"</string>
    <string name="find_broadcast_password_dialog_connection_error" msgid="47873617983439400">"Imeshindwa kuunganisha. Jaribu tena."</string>
    <string name="find_broadcast_password_dialog_password_error" msgid="243855327674765">"Nenosiri si sahihi"</string>
    <string name="find_broadcast_join_broadcast_error" msgid="5486980388774711346">"Imeshindwa kujiunga kwenye upokeaji wa arifa"</string>
    <string name="bt_le_audio_scan_qr_code_scanner" msgid="7614569515419813053">"Ili uanze kusikiliza, weka katikati msimbo wa QR ulio hapa chini"</string>
    <string name="bt_le_audio_qr_code_is_not_valid_format" msgid="7821837654128137901">"Msimbo wa QR si muundo sahihi"</string>
    <string name="convert_to_esim_title" msgid="71037864129009206">"Badilisha iwe eSIM"</string>
    <string name="transfer_esim_to_another_device_title" msgid="5286117866086383192">"Hamishia eSIM kwenye kifaa kingine"</string>
    <string name="background_install_preference_summary" msgid="3065219346519340364">"{count,plural, =1{Programu #}other{Programu #}}"</string>
    <string name="background_install_title" msgid="607913515188276168">"Programu zilizosakinishwa chinichini"</string>
    <string name="background_install_summary" msgid="3890296129543309666">"Mtengenezaji wa kifaa chako anaweza kusakinisha programu chinichini kwenye kifaa chako au kuruhusu mtoa huduma wako na washirika wengine wafanye hivyo.\n\nProgramu zozote zilizoorodheshwa hapa hazihitajiki ili kifaa chako kifanye kazi ipasavyo. Unaweza kuondoa programu usizohitaji."</string>
    <string name="background_install_feature_list_no_entry" msgid="2071343281272266154">"Hakuna programu zilizosakinishwa chinichini"</string>
    <string name="background_install_uninstall_button_description" msgid="1189649052911501249">"Ondoa programu"</string>
    <string name="background_install_before" msgid="8608614957688912715">"{count,plural, =1{Programu zilizosakinishwa mwezi # uliopita}other{Programu zilizosakinishwa miezi # iliyopita}}"</string>
    <string name="background_install_after" msgid="7983488897570908149">"{count,plural, =1{Programu zilizosakinishwa zaidi ya mwezi # uliopita}other{Programu zilizosakinishwa zaidi ya miezi # iliyopita}}"</string>
    <string name="aspect_ratio_title" msgid="2451826875939676101">"Uwiano"</string>
    <string name="aspect_ratio_summary" msgid="4056406351663726494">"Jaribu uwiano tofauti kuangalia maudhui kwenye programu hii endapo haijasanidiwa kuendana na <xliff:g id="DEVICE_NAME">%1$s</xliff:g> yako"</string>
    <string name="aspect_ratio_main_summary" msgid="4141964559612756940">"Jaribu uwiano tofauti kuangalia maudhui kwenye programu hii endapo haijasanidiwa kuendana na <xliff:g id="DEVICE_NAME">%1$s</xliff:g> yako. Huenda baadhi ya programu zisiweze kutumia uwiano fulani."</string>
    <string name="aspect_ratio_summary_text" msgid="4737461467467220325">"Jaribu uwiano tofauti kuangalia maudhui kwenye programu endapo haijasanidiwa kuendana na <xliff:g id="DEVICE_NAME">%1$s</xliff:g> yako"</string>
    <string name="aspect_ratio_main_summary_text" msgid="5544816872094235840">"Jaribu uwiano tofauti kuangalia maudhui kwenye programu endapo haijasanidiwa kuendana na <xliff:g id="DEVICE_NAME">%1$s</xliff:g> yako. Huenda baadhi ya programu zisiweze kutumia uwiano fulani."</string>
    <string name="user_aspect_ratio_suggested_apps_label" msgid="8085934042329632039">"Programu unazopendekezewa"</string>
    <string name="user_aspect_ratio_changed_apps_label" msgid="2096614916172567672">"Programu zilizobadilishwa"</string>
    <string name="user_aspect_ratio_app_default" msgid="270065763307617837">"Chaguomsingi la programu"</string>
    <string name="user_aspect_ratio_fullscreen" msgid="1843427242540081996">"Skrini nzima"</string>
    <string name="user_aspect_ratio_half_screen" msgid="1015852057094310209">"Nusu skrini"</string>
    <string name="user_aspect_ratio_device_size" msgid="2339820985120881199">"Uwiano wa kifaa"</string>
    <string name="user_aspect_ratio_16_9" msgid="2286644872775170164">"16:9"</string>
    <string name="user_aspect_ratio_3_2" msgid="199262962518318932">"3:2"</string>
    <string name="user_aspect_ratio_4_3" msgid="5196232982878982220">"4:3"</string>
    <string name="user_aspect_ratio_option_a11y" msgid="1235801996029095219">"<xliff:g id="NUMERATOR">%1$s</xliff:g> kwa <xliff:g id="DENOMINATOR">%2$s</xliff:g>"</string>
    <string name="app_aspect_ratio_footer" msgid="4029509301182067475">"Programu itafungwa kisha ifunguliwe upya utakapobadilisha uwiano. Huenda ukapoteza mabadiliko ambayo hujahifadhi. Huenda baadhi ya programu zisiweze kutumia uwiano fulani."</string>
    <string name="aspect_ratio_experimental_title" msgid="9088785421062044831">"Uwiano (wa majaribio)"</string>
    <string name="aspect_ratio_experiment_title" msgid="128614319422121040">"Uwiano (jaribio)"</string>
    <string name="aspect_ratio_labs_title" msgid="6733893837442759383">"Uwiano (maabara)"</string>
    <string name="aspect_ratio_experimental_label" msgid="6319009297672567578">"Wa majaribio"</string>
    <string name="aspect_ratio_experiment_label" msgid="7861871612376167784">"Jaribio"</string>
    <string name="aspect_ratio_labs_label" msgid="7008498116297651342">"Maabara"</string>
    <string name="accessibility_fingerprint_label" msgid="5017431423168191733">"Kitambua alama ya kidole"</string>
    <string name="flash_notifications_title" msgid="4490438861180492311">"Arifa za mweko"</string>
    <string name="flash_notifications_about_title" msgid="9004351252928121214">"Kuhusu arifa za mweko"</string>
    <string name="flash_notifications_summary_off" msgid="6056282996770691461">"Umezima"</string>
    <string name="flash_notifications_summary_on_camera" msgid="3286405833586333730">"Umewashwa / Mmweko wa kamera"</string>
    <string name="flash_notifications_summary_on_screen" msgid="9040640799633336219">"Umewashwa / mweko wa skrini"</string>
    <string name="flash_notifications_summary_on_camera_and_screen" msgid="2326268141063768701">"Umewashwa / mweko wa kamera na skrini"</string>
    <string name="flash_notifications_intro" msgid="8409873413480928249">"Washa mweko wa kamera au skrini unapopokea arifa au kengele zinapolia"</string>
    <string name="flash_notifications_intro_without_camera_flash" msgid="6297337174487793891">"Skrini imweke unapopokea arifa au kengele zinapolia"</string>
    <string name="flash_notifications_note" msgid="2426125248448055075">"Tumia arifa za mweko kwa tahadhari ikiwa unaathiriwa na mwangaza"</string>
    <string name="flash_notifications_keywords" msgid="2458759275318514836">"mweko, mwangaza, tatizo la kusikia, kupoteza uwezo wa kusikia"</string>
    <string name="flash_notifications_preview" msgid="5320176885050440874">"Onyesho la kukagua"</string>
    <string name="camera_flash_notification_title" msgid="2475084876382922732">"Mmweko wa kamera"</string>
    <string name="screen_flash_notification_title" msgid="3773100725793316708">"Mmweko wa skrini"</string>
    <string name="screen_flash_notification_color_title" msgid="7213407653340970790">"Rangi ya mweko wa skrini"</string>
    <string name="screen_flash_color_blue" msgid="3585766657607931371">"Samawati"</string>
    <string name="screen_flash_color_azure" msgid="8691198532944992243">"Samawati"</string>
    <string name="screen_flash_color_cyan" msgid="6878780006173747267">"Samawati-kijani"</string>
    <string name="screen_flash_color_spring_green" msgid="4466548514738457815">"Kijani kilichokolea"</string>
    <string name="screen_flash_color_green" msgid="8418019648507964564">"Kijani"</string>
    <string name="screen_flash_color_chartreuse_green" msgid="7456381649919010366">"Kijani kibichi"</string>
    <string name="screen_flash_color_yellow" msgid="7413465411615454556">"Manjano"</string>
    <string name="screen_flash_color_orange" msgid="979177126315557656">"Rangi ya chungwa"</string>
    <string name="screen_flash_color_red" msgid="8954162219886445491">"Nyekundu"</string>
    <string name="screen_flash_color_rose" msgid="1216848195972231251">"Waridi"</string>
    <string name="screen_flash_color_magenta" msgid="7726221666557102155">"Majenta"</string>
    <string name="screen_flash_color_violet" msgid="1279950780509029495">"Zambarau iliyokolea"</string>
    <string name="color_selector_dialog_done" msgid="121253968943363376">"Nimemaliza"</string>
    <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Ghairi"</string>
    <string name="contrast_title" msgid="6885768151336508075">"Utofautishaji"</string>
    <string name="contrast_standard" msgid="1097297089917185235">"Kawaida"</string>
    <!-- no translation found for contrast_default (8918545965525226966) -->
    <skip />
    <string name="contrast_medium" msgid="384414510709285811">"Wastani"</string>
    <string name="contrast_high" msgid="3988567609694797696">"Juu"</string>
    <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Programu hii inaweza kufunguliwa katika dirisha 1 pekee"</string>
    <string name="generic_accessibility_service_on" msgid="4466229372357726824">"Kimewashwa"</string>
    <string name="generic_accessibility_service_off" msgid="4759859497651675724">"Kimezimwa"</string>
    <string name="generic_accessibility_feature_shortcut_off" msgid="4022872394514077907">"Kimezimwa"</string>
    <string name="accessibility_shortcut_state_off" msgid="8158137799007601475">"Imezimwa"</string>
    <string name="daltonizer_state_on" msgid="131013270022603983">"Imewashwa"</string>
    <string name="daltonizer_state_off" msgid="1162285688069856179">"Imezimwa"</string>
    <string name="color_inversion_state_on" msgid="1160969033636440368">"Imewashwa"</string>
    <string name="color_inversion_state_off" msgid="6925638668080451724">"Imezimwa"</string>
    <string name="color_inversion_feature_summary" msgid="1199876648549627647">"Hugeuza skrini nyeupe kuwa nyeusi na skrini nyeusi kuwa nyeupe"</string>
    <string name="magnification_feature_summary" msgid="2053971569640663564">"Vuta karibu kwenye skrini"</string>
    <string name="autoclick_disabled" msgid="3213396804955002120">"Imezimwa"</string>
    <string name="show_captions_disabled" msgid="690650956523818755">"Imezimwa"</string>
    <string name="show_captions_enabled" msgid="7089043007924626">"Imewashwa"</string>
    <string name="live_caption_disabled" msgid="3562035026547887366">"Imezimwa"</string>
    <string name="live_caption_enabled" msgid="5269360946200718949">"Imewashwa"</string>
    <string name="about_phone_device_name_warning" msgid="3243226572404472381">"Jina la kifaa chako litaonekana kwa programu ambazo umesakinisha. Huenda likaonekana pia na watu wengine unapooanisha na vifaa vyenye Bluetooth, unapounganisha kwenye mtandao wa Wi-Fi au unapoweka mipangilio ya mtandao pepe wa Wi-Fi."</string>
    <string name="grammatical_gender_title" msgid="8584242850477270828">"Jinsia ya kisarufi"</string>
    <string name="grammatical_gender_dialog_title" msgid="8754048592099871587">"Chagua Jinsia ya kisarufi"</string>
    <string name="content_protection_preference_title" msgid="5069260032659193074">"Inatafuta programu hasidi"</string>
    <string name="content_protection_preference_summary" msgid="2252393849408445391">"Kagua shughuli kwenye programu ili kubaini iwapo kuna wizi wa data binafsi"</string>
    <string name="content_protection_preference_user_consent_switch_title" msgid="1797782616799594426">"Kagua ili ugundue programu za kilaghai"</string>
    <string name="content_protection_preference_user_consent_work_profile_switch_title" msgid="3004347470520916069">"Kagua ili ugundue programu za kilaghai za kazini"</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">"Imekamilisha kuweka nenosiri"</string>
    <string name="show_stylus_pointer_icon" msgid="1010583689203665786">"Onyesha kielekezi unapowekelea kiashiria"</string>
</resources>
