<?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">"Ya"</string>
    <string name="no" msgid="5541738710521607130">"Tidak"</string>
    <string name="create" msgid="986997212165228751">"Buat"</string>
    <string name="allow" msgid="3763244945363657722">"Izinkan"</string>
    <string name="deny" msgid="7326117222944479942">"Tolak"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Aktifkan"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Tidak diketahui"</string>
    <string name="device_info_protected_single_press" msgid="3810785480060743677">"Ketuk untuk menampilkan info"</string>
    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{Anda perlu menyelesaikan # langkah lagi untuk menjadi developer.}other{Anda perlu menyelesaikan # langkah lagi untuk menjadi developer.}}"</string>
    <string name="show_dev_on" msgid="2840850085134853754">"Sekarang Anda adalah seorang developer!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Tidak perlu, Anda sudah menjadi developer."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Aktifkan opsi developer terlebih dahulu."</string>
    <string name="header_category_system" msgid="1665516346845259058">"Sistem"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"Dalam Layanan"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Di Luar Area Layanan"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Radio Nonaktif"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Tidak Roaming"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Sambungan terputus"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Menghubungkan"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Terhubung"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Ditangguhkan"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Tidak diketahui"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Pratinjau"</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Buat lebih kecil"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Buat lebih besar"</string>
    <string name="auto_rotate_settings_primary_switch_title" msgid="3440951924928594520">"Gunakan putar otomatis"</string>
    <string name="smart_rotate_text_headline" msgid="5878008933992951904">"Fitur Deteksi Wajah menggunakan kamera depan untuk meningkatkan akurasi putar otomatis. Gambar tidak pernah disimpan atau dikirim ke Google."</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Terlihat utk semua perangkat Bluetooth terdekat (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Terlihat untuk semua perangkat Bluetooth terdekat"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Tidak terlihat oleh perangkat Bluetooth lain"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Hanya terlihat oleh perangkat yang disandingkan"</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Perangkat bluetooth"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Nama perangkat"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Ganti nama perangkat ini"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Ganti nama"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Putuskan sambungan perangkat?"</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Sambungkan perangkat baru"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"bluetooth"</string>
    <string name="bluetooth_pair_right_ear_button" msgid="3979894494803078852">"Sambungkan ke telinga kanan"</string>
    <string name="bluetooth_pair_left_ear_button" msgid="1019938875726073791">"Sambungkan ke telinga kiri"</string>
    <string name="bluetooth_pair_other_ear_dialog_title" msgid="3814943511999984012">"Sambungkan ke telinga satunya"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_message" msgid="5711642363615781647">"Alat bantu dengar telinga kiri terhubung.\n\nUntuk menyambungkan yang sebelah kanan, pastikan alat sudah dinyalakan dan siap disambungkan."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message" msgid="631521133525979967">"Alat bantu dengar telinga kanan terhubung.\n\nUntuk menyambungkan yang sebelah kiri, pastikan alat sudah dinyalakan dan siap disambungkan."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Sambungkan ke telinga kanan"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Sambungkan ke telinga kiri"</string>
    <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Untuk semua alat bantu dengar yang tersedia"</string>
    <string name="bluetooth_device_controls_title" msgid="1895676556354697234">"Setelan alat bantu dengar"</string>
    <string name="bluetooth_device_controls_summary" msgid="8115767735418425663">"Pintasan, kompatibilitas alat bantu dengar (HAC)"</string>
    <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Untuk perangkat ini"</string>
    <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Output audio"</string>
    <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Tentang output audio"</string>
    <string name="bluetooth_audio_routing_summary" msgid="7180947533985969066">"Arahkan suara ke alat bantu dengar atau speaker ponsel"</string>
    <string name="bluetooth_screen_related" msgid="7976543255501825536">"Terkait"</string>
    <string name="bluetooth_ringtone_title" msgid="3177308461256892085">"Nada dering dan alarm"</string>
    <string name="bluetooth_call_title" msgid="6851464952021874072">"Audio saat panggilan"</string>
    <string name="bluetooth_media_title" msgid="343705257183053699">"Media"</string>
    <string name="bluetooth_system_sounds_title" msgid="6746938637128763205">"Suara notifikasi dan sistem lainnya"</string>
    <string name="bluetooth_audio_routing_footer_summary" msgid="410260713589309293">"Secara default, output audio ditentukan oleh masing-masing aplikasi"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Perangkat Bluetooth tak bernama"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Menelusuri"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"Tak ada prngkt Bluetooth terdekat."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Permintaan penyambungan Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Permintaan penyambungan"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Ketuk untuk menyambungkan dengan <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"Bluetooth nonaktif"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Ketuk untuk mengaktifkannya"</string>
    <string name="device_picker" msgid="2427027896389445414">"Pilih perangkat Bluetooth"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"<xliff:g id="APP_NAME">%1$s</xliff:g> ingin mengaktifkan Bluetooth"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"<xliff:g id="APP_NAME">%1$s</xliff:g> ingin menonaktifkan Bluetooth"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"Sebuah aplikasi ingin mengaktifkan Bluetooth"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"Sebuah aplikasi ingin menonaktifkan Bluetooth"</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Menyalakan Bluetooth..."</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Mematikan Bluetooth…"</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Permintaan sambungan bluetooth"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Permintaan akses buku telepon"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Permintaan akses pesan"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Terlihat sebagai “<xliff:g id="DEVICE_NAME">^1</xliff:g>” oleh perangkat lain"</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Aktifkan Bluetooth untuk menghubungkan ke perangkat lain."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Perangkat Anda"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Sambungkan perangkat baru"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Nonaktifkan offload hardware Bluetooth A2DP"</string>
    <string name="bluetooth_disable_le_audio_hw_offload" msgid="4656853795514691257">"Nonaktifkan offload hardware Bluetooth LE audio"</string>
    <string name="bluetooth_disable_hw_offload_dialog_title" msgid="6001142380445276918">"Mulai Ulang Perangkat?"</string>
    <string name="bluetooth_disable_hw_offload_dialog_message" msgid="1524373895333698779">"Anda perlu memulai ulang perangkat untuk mengubah setelan ini."</string>
    <string name="bluetooth_disable_hw_offload_dialog_confirm" msgid="5594859658551707592">"Mulai ulang"</string>
    <string name="bluetooth_disable_hw_offload_dialog_cancel" msgid="3663690305043973720">"Batal"</string>
    <string name="bluetooth_disable_leaudio" msgid="8619410595945155354">"Nonaktifkan Bluetooth LE Audio"</string>
    <string name="bluetooth_disable_leaudio_summary" msgid="4756307633476985470">"Nonaktifkan fitur Bluetooth LE Audio jika perangkat mendukung kemampuan hardware LE Audio."</string>
    <string name="bluetooth_show_leaudio_device_details" msgid="3306637862550475370">"Tampilkan tombol LE audio di Detail Perangkat"</string>
    <string name="bluetooth_enable_leaudio_allow_list" msgid="1692999156437357534">"Aktifkan Daftar yang Diizinkan Bluetooth LE Audio"</string>
    <string name="bluetooth_enable_leaudio_allow_list_summary" msgid="725601205276008525">"Aktifkan fitur daftar yang diizinkan Bluetooth LE Audio."</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Perangkat Media"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Perangkat panggilan telepon"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Perangkat lain"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Perangkat tersimpan"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Bluetooth akan diaktifkan untuk menyambungkan"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Preferensi koneksi"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Terhubung sebelumnya"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"Bluetooth diaktifkan"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Lihat semua"</string>
    <string name="stylus_device_details_title" msgid="7618295136015480864">"Stilus"</string>
    <string name="stylus_default_notes_app" msgid="3896158797687806941">"Aplikasi catatan default"</string>
    <string name="stylus_textfield_handwriting" msgid="2363579035338976327">"Menulis di kolom teks"</string>
    <string name="stylus_ignore_button" msgid="7734540973145241391">"Abaikan semua penekanan tombol dengan stilus"</string>
    <string name="stylus_connected_devices_title" msgid="2823967577941359812">"Stilus"</string>
    <string name="date_and_time" msgid="1788358029823431692">"Tanggal &amp; waktu"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Proxy"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Bersihkan"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Port proxy"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Abaikan proxy untuk"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Pulihkan default"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Selesai"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Nama host proxy"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Perhatian"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"Oke"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"Nama host yang Anda ketikkan tidak valid."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"Daftar pengecualian yang Anda ketikkan tidak diformat dengan benar. Ketikkan daftar pengecualian domain dengan dipisahkan koma."</string>
    <string name="proxy_error_empty_port" msgid="4250295137005082992">"Anda perlu melengkapi bidang port."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"Bidang port harus kosong jika bidang host kosong."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"Port yang Anda ketik tidak valid."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"Proxy HTTP digunakan oleh browser, tetapi tidak boleh digunakan oleh aplikasi lain."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"URL PAC: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Ping Hostname(www.google.com) IPv4:"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"Uji Klien HTTP:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Jalankan Uji Ping"</string>
    <string name="skip_label" msgid="6380034601349015895">"Lewati"</string>
    <string name="next_label" msgid="1248293387735652187">"Berikutnya"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Bahasa"</string>
    <string name="language_picker_category_title" msgid="1792199453060454565">"Urutan bahasa pilihan"</string>
    <string name="desc_current_default_language" msgid="1901157141663662859">"Bahasa sistem"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Hapus"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Tambahkan bahasa"</string>
    <string name="app_locale_preference_title" msgid="5513627099300360232">"Bahasa"</string>
    <string name="locale_picker_category_title" msgid="6212064706962721255">"Bahasa pilihan"</string>
    <string name="app_locales_picker_menu_title" msgid="7617427959223831373">"Bahasa aplikasi"</string>
    <string name="app_locale_picker_summary" msgid="6742557329924446252">"Setel bahasa untuk setiap aplikasi"</string>
    <string name="app_locale_picker_title" msgid="2431448962911301366">"Bahasa aplikasi"</string>
    <string name="suggested_app_locales_title" msgid="8898358282377369405">"Bahasa yang disarankan"</string>
    <string name="all_supported_app_locales_title" msgid="5479289964316009026">"Semua bahasa"</string>
    <string name="preference_of_system_locale_title" msgid="8067226276038751504">"Bahasa sistem"</string>
    <string name="preference_of_system_locale_summary" msgid="5612241394431188535">"Default sistem"</string>
    <string name="desc_no_available_supported_locale" msgid="7883271726226947273">"Pemilihan bahasa untuk aplikasi ini tidak tersedia dari Setelan."</string>
    <string name="desc_app_locale_disclaimer" msgid="5295933110644789052">"Bahasa mungkin berbeda dari bahasa yang tersedia di aplikasi. Beberapa aplikasi mungkin tidak mendukung setelan ini."</string>
    <string name="desc_app_locale_selection_supported" msgid="6744909281573556379">"Setel bahasa untuk setiap aplikasi."</string>
    <string name="desc_introduction_of_language_picker" msgid="1038423471887102449">"Sistem, aplikasi, dan situs menggunakan bahasa pertama yang didukung dalam daftar bahasa pilihan Anda."</string>
    <string name="desc_notice_of_language_picker" msgid="3449290526457925447">"Untuk memilih bahasa bagi setiap aplikasi, buka setelan bahasa aplikasi."</string>
    <string name="desc_locale_helper_footer_general" msgid="6112153921151780303">"Pelajari bahasa aplikasi lebih lanjut"</string>
    <string name="title_change_system_locale" msgid="8589844586256566951">"Ubah bahasa sistem menjadi %s?"</string>
    <string name="desc_notice_device_locale_settings_change" msgid="8311132485850714160">"Setelan dan preferensi regional perangkat akan berubah."</string>
    <string name="button_label_confirmation_of_system_locale_change" msgid="5593798559604894733">"Ubah"</string>
    <string name="title_unavailable_locale" msgid="2628898110416542386">"%s tidak tersedia"</string>
    <string name="desc_unavailable_locale" msgid="2201756477400935896">"Bahasa ini tidak dapat digunakan sebagai bahasa sistem, tetapi Anda telah memberi tahu aplikasi dan situs bahwa ini adalah bahasa pilihan Anda."</string>
    <string name="regional_preferences_title" msgid="4304567374498629528">"Preferensi regional"</string>
    <string name="regional_preferences_summary" msgid="1189876997389469650">"Setel preferensi satuan dan angka"</string>
    <string name="regional_preferences_main_page_sub_title" msgid="4237109940015254725">"Izinkan aplikasi mengetahui preferensi regional Anda sehingga dapat mempersonalisasi pengalaman Anda."</string>
    <string name="regional_preferences_option_page_sub_title" msgid="8303661099255197036">"Aplikasi akan menggunakan preferensi regional Anda jika memungkinkan."</string>
    <string name="temperature_preferences_title" msgid="5009881556503629058">"Suhu"</string>
    <string name="first_day_of_week_preferences_title" msgid="1971850087589599553">"Hari pertama dalam seminggu"</string>
    <string name="numbers_preferences_title" msgid="8197418984391195446">"Preferensi angka"</string>
    <string name="default_string_of_regional_preference" msgid="7662581547334113719">"Gunakan default aplikasi"</string>
    <string name="celsius_temperature_unit" msgid="8896459071273084507">"Celsius (°C)"</string>
    <string name="fahrenheit_temperature_unit" msgid="1118677820614569801">"Fahrenheit (°F)"</string>
    <string name="sunday_first_day_of_week" msgid="7644548348295686051">"Minggu"</string>
    <string name="monday_first_day_of_week" msgid="7244698610476506771">"Senin"</string>
    <string name="tuesday_first_day_of_week" msgid="5085370946936582391">"Selasa"</string>
    <string name="wednesday_first_day_of_week" msgid="6544537589727042869">"Rabu"</string>
    <string name="thursday_first_day_of_week" msgid="3035885630945594833">"Kamis"</string>
    <string name="friday_first_day_of_week" msgid="7074795061812083541">"Jumat"</string>
    <string name="saturday_first_day_of_week" msgid="3702282590450322727">"Sabtu"</string>
    <string name="title_regional_pref_footer" msgid="7450438024324794380">"Jika tidak mendukung preferensi regional, aplikasi akan menggunakan setelan lokalitas defaultnya."</string>
    <string name="desc_regional_pref_footer_learn_more" msgid="4401708653329230081">"Pelajari lebih lanjut preferensi bahasa."</string>
    <string name="dlg_remove_locales_title" msgid="3170501604483612114">"{count,plural, =1{Hapus bahasa yang dipilih?}other{Hapus bahasa yang dipilih?}}"</string>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Teks akan ditampilkan dalam bahasa lain."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Tidak dapat menghapus semua bahasa"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Simpan sedikitnya satu bahasa pilihan"</string>
    <string name="locale_not_translated" msgid="3071618135527110152">"Tidak tersedia sebagai bahasa sistem"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Naikkan"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Turunkan"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Pindahkan ke atas"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Pindahkan ke bawah"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Hapus bahasa"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Pilih kegiatan"</string>
    <string name="cancel" msgid="5780102414089664898">"Batal"</string>
    <string name="okay" msgid="4827099303045669054">"Oke"</string>
    <string name="forget" msgid="3754013654135912783">"Lupakan"</string>
    <string name="save" msgid="3125033126936493822">"Simpan"</string>
    <string name="done" msgid="7497982645646431310">"Selesai"</string>
    <string name="apply" msgid="7834684883190163536">"Terapkan"</string>
    <string name="share" msgid="8502235338607613795">"Bagikan"</string>
    <string name="add" msgid="8335206931421683426">"Tambahkan"</string>
    <string name="remove" msgid="1028414219245072102">"Hapus"</string>
    <string name="settings_label" msgid="943294133671632976">"Setelan"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Setelan"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Pintasan setelan"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Mode pesawat"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Jaringan &amp; nirkabel"</string>
    <string name="roaming" msgid="3055365654530847985">"Roaming"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Terhubung ke layanan data ketika roaming"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Terhubung ke layanan data ketika roaming"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Biaya roaming dapat berlaku."</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Setel waktu otomatis"</string>
    <string name="zone_auto_title" msgid="5141692422373097957">"Setel otomatis"</string>
    <string name="auto_zone_requires_location_summary" msgid="4831038184260596735">"Lokasi akan digunakan untuk menyetel zona waktu saat tombol ini aktif"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Gunakan default lokalitas"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"Gunakan format 24 jam"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Waktu"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Format waktu"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Zona waktu"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Pilih zona waktu"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Tanggal"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Telusuri wilayah"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Wilayah"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"Pilih selisih waktu 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">"Menggunakan <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> dimulai pada <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8399585343328811158">"Menggunakan <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Tidak ada waktu daylight saving."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Waktu musim panas"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Waktu standar"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Pilih menurut wilayah"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Pilih sesuai selisih waktu UTC"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Waktu tunggu layar sebelum mengunci"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> setelah waktu tunggu"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Segera setelah waktu tunggu, kecuali jika tetap tidak dikunci oleh <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> setelah waktu tunggu, kecuali jika tetap tidak dikunci oleh <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g>"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Tambahkan teks di layar kunci"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Tidak ada"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"Misalnya, Android Joko."</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Lokasi"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Gunakan lokasi"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Nonaktif"</string>
    <string name="location_settings_summary_location_on" msgid="7029728269719893381">"{count,plural, =1{Aktif - # aplikasi memiliki akses ke lokasi}other{Aktif - # aplikasi memiliki akses ke lokasi}}"</string>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Memuat…"</string>
    <string name="location_settings_footer_general" msgid="1040507068701188821">"Aplikasi dengan izin Perangkat di sekitar dapat menentukan posisi relatif perangkat terhubung."</string>
    <string name="location_settings_footer_location_off" msgid="8568995909147566720">"Akses lokasi dinonaktifkan untuk aplikasi dan layanan. Lokasi perangkat Anda tetap dapat dikirimkan ke petugas tanggap darurat saat Anda menelepon atau mengirim SMS ke nomor darurat."</string>
    <string name="location_settings_footer_learn_more_content_description" msgid="5329024810729665156">"Pelajari Setelan Lokasi lebih lanjut."</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Akun"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Keamanan"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Enkripsi &amp; kredensial"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Layar kunci"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Elemen yang ditampilkan"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Tidak tersedia"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Status keamanan"</string>
    <string name="security_dashboard_summary" msgid="7571035662779425918">"Kunci layar, Temukan Perangkat Saya, keamanan aplikasi"</string>
    <string name="safety_center_title" msgid="7732397372178774777">"Keamanan &amp; privasi"</string>
    <string name="safety_center_summary" msgid="3554867379951053869">"Keamanan aplikasi, kunci perangkat, izin"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Wajah ditambahkan"</string>
    <string name="security_settings_face_preference_summary_none" msgid="523320857738436024">"Penyiapan diperlukan"</string>
    <string name="security_settings_face_preference_title" msgid="2126625155005348417">"Buka dengan Wajah"</string>
    <string name="security_settings_face_profile_preference_title" msgid="7519527436266375005">"Buka dengan Wajah untuk profil kerja"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6448806884597691208">"Cara menyiapkan Buka dengan Wajah"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="3701874093226957891">"Siapkan Buka dengan Wajah"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Gunakan wajah Anda untuk mengautentikasi"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Mulai"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="2965952386172202665">"Jika Buka dengan Wajah aksesibilitas dinonaktifkan, beberapa langkah penyiapan mungkin tidak akan berfungsi baik dengan TalkBack."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Kembali"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Lanjutkan penyiapan"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Gunakan penyiapan aksesibilitas"</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">"Batal"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Lain kali"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"Saya setuju"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Selengkapnya"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Buka kunci dengan wajah Anda"</string>
    <string name="security_settings_face_enroll_consent_introduction_title" msgid="3942331854413767814">"Izinkan buka kunci dengan wajah"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Gunakan wajah Anda untuk mengautentikasi"</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Gunakan sidik jari untuk membuka ponsel atau menyetujui pembelian.\n\nCatatan: Anda tidak dapat menggunakan sidik jari untuk membuka perangkat ini. Untuk informasi selengkapnya, hubungi admin organisasi Anda."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Gunakan wajah Anda untuk membuka kunci ponsel, mengizinkan pembelian, atau login ke aplikasi"</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">"Posisikan wajah Anda di tengah lingkaran"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Lewati"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Anda telah menambahkan jumlah maksimum wajah"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"Tidak dapat menambahkan wajah lagi"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"Pendaftaran tidak selesai"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="1674650455786434426">"Ya"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="7768349698547951750">"Batas waktu pendaftaran wajah tercapai. Coba lagi."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"Pendaftaran wajah gagal."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Selesai. Terlihat bagus."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Selesai"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="6835778900387289683">"Tingkatkan performa Buka dengan Wajah"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="7055780282999744813">"Siapkan Buka dengan Wajah lagi"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="4421818770682557621">"Siapkan Buka dengan Wajah lagi"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Tingkatkan keamanan dan performa"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="6194184776580066012">"Siapkan Buka dengan Wajah"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="2670118180411127323">"Hapus model wajah Anda saat ini untuk menyiapkan Buka dengan Wajah lagi.\n\nModel wajah Anda akan dihapus secara permanen dan aman.\n\nSetelah dihapus, Anda akan memerlukan PIN, pola, atau sandi untuk membuka kunci ponsel atau untuk autentikasi dalam aplikasi."</string>
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint" msgid="2469599074650327489">"Hapus model wajah Anda saat ini untuk menyiapkan Buka dengan Wajah lagi.\n\nModel wajah Anda akan dihapus secara permanen dan aman.\n\nSetelah dihapus, Anda akan memerlukan sidik jari, PIN, pola, atau sandi untuk membuka kunci ponsel atau untuk autentikasi dalam aplikasi."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="1638314154119800188">"Gunakan Buka dengan Wajah untuk"</string>
    <string name="security_settings_face_settings_preferences_category" msgid="7628929873407280453">"Saat menggunakan Buka dengan Wajah"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Wajibkan mata terbuka"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Untuk membuka kunci ponsel, mata Anda harus terbuka"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Selalu wajibkan konfirmasi"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="3498729789625461914">"Saat memakai Buka dengan Wajah di aplikasi, selalu minta langkah konfirmasi"</string>
    <string name="security_settings_face_settings_remove_face_model" msgid="812920481303980846">"Hapus model wajah"</string>
    <string name="security_settings_face_settings_enroll" msgid="3726313826693825029">"Siapkan Buka dengan Wajah"</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2899669764446232715">"Hapus model wajah?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="916131485988121592">"Model wajah Anda akan dihapus secara permanen dan aman.\n\nSetelah penghapusan, Anda akan memerlukan PIN, pola, atau sandi untuk membuka kunci ponsel atau untuk tujuan autentikasi dalam aplikasi."</string>
    <string name="security_settings_face_settings_remove_dialog_details_convenience" msgid="475568135197468990">"Model wajah Anda akan dihapus secara permanen dan aman.\n\nSetelah dihapus, Anda akan memerlukan PIN, pola, atau sandi untuk membuka kunci ponsel."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="8284262560781442403">"Gunakan Buka dengan Wajah untuk membuka kunci ponsel Anda"</string>
    <string name="security_settings_fingerprint" msgid="6387775386189204201">"Sidik jari"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Sidik jari"</string>
    <string name="security_settings_fingerprint_settings_preferences_category" msgid="8975029409126780752">"Jika menggunakan Buka dengan Sidik Jari"</string>
    <string name="security_settings_work_fingerprint_preference_title" msgid="2076006873519745979">"Sidik jari untuk profil kerja"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Tambahkan sidik jari"</string>
    <string name="security_settings_fingerprint_preference_summary" msgid="8486134175759676037">"{count,plural, =1{Sidik jari ditambahkan}other{# sidik jari ditambahkan}}"</string>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1146977379031250790">"Penyiapan diperlukan"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="7931650601996313070">"Siapkan sidik jari Anda"</string>
    <string name="security_settings_fingerprint_enroll_consent_introduction_title" msgid="2278592030102282364">"Izinkan buka kunci dengan sidik jari"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Menggunakan sidik jari"</string>
    <string name="security_settings_fingerprint_settings_footer_learn_more" msgid="2508322993726483601">"Pelajari Buka dengan Sidik Jari lebih lanjut"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_1" msgid="6808124116419325722">"Kendali di tangan Anda"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1" msgid="1122676690472680734">"Anda dan anak Anda memegang kendali"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2" msgid="5663733424583416266">"Ingat"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Gunakan sidik jari untuk membuka ponsel atau menyetujui pembelian.\n\nCatatan: Anda tidak dapat menggunakan sidik jari untuk membuka perangkat ini. Untuk informasi selengkapnya, hubungi admin organisasi Anda."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Batal"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"Lain kali"</string>
    <string name="security_settings_fingerprint_enroll_introduction_agree" msgid="4068276083536421828">"Saya setuju"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Lewati sidik jari?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"Penyiapan sidik jari hanya memerlukan waktu 1 atau 2 menit. Jika melewati langkah ini sekarang, Anda dapat menambahkan sidik jari lain kali di Setelan."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_setup" msgid="6255210343107484206">"Jika Anda melihat ikon ini, gunakan sidik jari untuk autentikasi, seperti saat Anda login ke aplikasi atau menyetujui pembelian"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_1" msgid="4360262371633254407">"Ingat"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2" msgid="2580899232734177771">"Cara kerjanya"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2" msgid="5909924864816776516">"Buka dengan Sidik Jari membuat model unik sidik jari untuk memverifikasi diri Anda. Untuk membuat model sidik jari ini selama penyiapan, Anda akan mengambil gambar sidik jari dari berbagai posisi."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2" msgid="3493356605815124807">"Buka dengan Sidik Jari membuat model unik dari sidik jari anak Anda untuk memverifikasi dirinya. Untuk membuat model sidik jari ini selama penyiapan, dia akan mengambil gambar sidik jari dari berbagai posisi."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6" msgid="5314031490467481499">"Untuk hasil terbaik, gunakan pelindung layar yang bersertifikasi Made for Google. Jika pelindung layar lain digunakan, sidik jari Anda mungkin tidak akan berfungsi."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6" msgid="3563942520716110478">"Untuk hasil terbaik, gunakan pelindung layar yang bersertifikasi Made for Google. Jika pelindung layar lain digunakan, sidik jari anak Anda mungkin tidak akan berfungsi."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_learn_more" msgid="5856010507790137793"></string>
    <string name="security_settings_activeunlock_preference_title" msgid="4257580421087062228">"Buka dengan Smartwatch"</string>
    <string name="biometric_settings_intro_with_activeunlock" msgid="6583248094453119314">"Jika Anda telah menyiapkan Buka dengan Wajah dan Buka dengan Sidik Jari, ponsel akan meminta sidik jari saat Anda memakai masker atau berada di area yang gelap.\n\nAnda dapat membuka kunci dengan smartwatch saat wajah atau sidik jari Anda tidak dikenali."</string>
    <string name="biometric_settings_intro_with_fingerprint" msgid="4312041617237493461">"Anda dapat membuka kunci dengan smartwatch saat sidik jari Anda tidak dikenali."</string>
    <string name="biometric_settings_intro_with_face" msgid="7658123658803417930">"Anda dapat membuka kunci dengan smartwatch saat wajah Anda tidak dikenali."</string>
    <string name="biometric_settings_use_fingerprint_or_watch_for" msgid="1160830065613858095">"Gunakan sidik jari atau smartwatch untuk"</string>
    <string name="biometric_settings_use_face_or_watch_for" msgid="1507077107150278532">"Gunakan wajah atau smartwatch untuk"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_for" msgid="7495835723072020641">"Gunakan wajah, sidik jari, atau smartwatch untuk"</string>
    <string name="biometric_settings_use_watch_for" msgid="5454545622244040110">"Gunakan smartwatch untuk"</string>
    <string name="biometric_settings_use_face_or_watch_preference_summary" msgid="4969685200340861744">"Menggunakan wajah atau smartwatch"</string>
    <string name="biometric_settings_use_fingerprint_or_watch_preference_summary" msgid="2425628094194828407">"Menggunakan sidik jari atau smartwatch"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary" msgid="188805113048792007">"Menggunakan wajah, sidik jari, atau smartwatch"</string>
    <string name="biometric_settings_use_watch_preference_summary" msgid="2311453276747908475">"Menggunakan smartwatch"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_title" msgid="8776904312629209685">"Siapkan Buka dengan Wajah atau Sidik Jari terlebih dahulu"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_message" msgid="1669326067732567911">"Anda dapat membuka kunci dengan smartwatch saat wajah atau sidik jari Anda tidak dikenali"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_title" msgid="6703703635881050623">"Siapkan Buka dengan Sidik Jari terlebih dahulu"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_message" msgid="4966813766409918392">"Anda dapat membuka kunci dengan smartwatch saat sidik jari Anda tidak dikenali"</string>
    <string name="security_settings_activeunlock_require_face_setup_title" msgid="1428795376597739880">"Siapkan Buka dengan Wajah terlebih dahulu"</string>
    <string name="security_settings_activeunlock_require_face_setup_message" msgid="8904070645721933399">"Anda dapat membuka kunci dengan smartwatch saat wajah Anda tidak dikenali"</string>
    <string name="security_settings_activeunlock_biometric_setup" msgid="8876454457817955475">"Siapkan"</string>
    <string name="security_settings_fingerprint_single_watch_preference_summary" msgid="6464470096384164369">"Sidik jari dan <xliff:g id="WATCH">%s</xliff:g> ditambahkan"</string>
    <string name="security_settings_fingerprint_multiple_watch_preference_summary" msgid="2259261786932097004">"Sidik jari dan <xliff:g id="WATCH">%s</xliff:g> ditambahkan"</string>
    <string name="security_settings_face_watch_preference_summary" msgid="5817376447253802793">"Wajah dan <xliff:g id="WATCH">%s</xliff:g> ditambahkan"</string>
    <string name="security_settings_fingerprint_single_face_watch_preference_summary" msgid="764951912234638192">"Wajah, sidik jari, dan <xliff:g id="WATCH">%s</xliff:g> ditambahkan"</string>
    <string name="security_settings_fingerprint_multiple_face_watch_preference_summary" msgid="3935500711366489380">"Wajah, sidik jari, dan <xliff:g id="WATCH">%s</xliff:g> ditambahkan"</string>
    <string name="security_settings_biometric_preference_title" msgid="298146483579539448">"Buka dengan Wajah &amp; Sidik Jari"</string>
    <string name="security_settings_work_biometric_preference_title" msgid="3121755615533533585">"Buka dengan Wajah &amp; Sidik Jari untuk profil kerja"</string>
    <string name="security_settings_biometric_preference_summary_none_enrolled" msgid="213377753727694575">"Penyiapan diperlukan"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_multiple" msgid="4821859306609955966">"Wajah dan sidik jari ditambahkan"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_single" msgid="684409535278676426">"Wajah dan sidik jari ditambahkan"</string>
    <string name="biometric_settings_intro" msgid="4263069383955676756">"Jika Anda telah menyiapkan Buka dengan Wajah dan Buka dengan Sidik Jari, ponsel akan meminta sidik jari saat Anda memakai masker atau berada di area yang gelap"</string>
    <string name="biometric_settings_category_ways_to_unlock" msgid="3384767901580915266">"Cara membuka kunci"</string>
    <string name="biometric_settings_category_use_face_fingerprint" msgid="4377659744376863913">"Gunakan wajah atau sidik jari untuk"</string>
    <string name="biometric_settings_use_biometric_unlock_phone" msgid="8180914579885804358">"Membuka kunci ponsel"</string>
    <string name="biometric_settings_use_biometric_for_apps" msgid="6201168728906364189">"Verifikasi diri Anda di aplikasi"</string>
    <string name="biometric_settings_use_face_preference_summary" msgid="1821648836899408477">"Menggunakan wajah"</string>
    <string name="biometric_settings_use_fingerprint_preference_summary" msgid="6077762097826050165">"Menggunakan sidik jari"</string>
    <string name="biometric_settings_use_face_or_fingerprint_preference_summary" msgid="3029102492674234728">"Menggunakan wajah atau sidik jari"</string>
    <string name="biometric_settings_hand_back_to_guardian_ok" msgid="1763788801883247426">"Oke"</string>
    <string name="biometric_settings_add_face_in_split_mode_title" msgid="6041232223862753222">"Tidak dapat menyiapkan Buka dengan Wajah"</string>
    <string name="biometric_settings_add_face_in_split_mode_message" msgid="1904738532939614456">"Keluar dari mode layar terpisah untuk menyiapkan Buka dengan Wajah"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_title" msgid="9194670722730454903">"Tidak dapat menyiapkan sidik jari"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_message" msgid="6960548382076629454">"Keluar dari mode layar terpisah untuk menyiapkan Buka dengan Sidik Jari"</string>
    <string name="biometric_settings_add_biometrics_in_split_mode_ok" msgid="564103789097253645">"Oke"</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Lewati kunci layar?"</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Tetap lewati"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Kembali"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Lewati"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Batal"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Sentuh sensor"</string>
    <string name="security_settings_sfps_enroll_find_sensor_title" msgid="8327884364635804363">"Sentuh tombol daya tanpa menekannya"</string>
    <string name="security_settings_udfps_enroll_find_sensor_title" msgid="8077484429913330179">"Cara menyiapkan sidik jari"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"Ada di bagian belakang ponsel. Gunakan jari telunjuk Anda."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="8383106460819519961">"Sensor sidik jari ada di layar. Anda akan merekam sidik jari Anda di layar berikutnya."</string>
    <string name="security_settings_udfps_enroll_find_sensor_start_button" msgid="3172268783620336357">"Mulai"</string>
    <string name="security_settings_udfps_enroll_a11y" msgid="1899453114050362235">"Gerakkan jari Anda di layar untuk menemukan sensor. Sentuh lama sensor sidik jari."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Ilustrasi dengan perangkat dan lokasi sensor sidik jari"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Nama"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"Oke"</string>
    <string name="security_settings_fingerprint_enroll_dialog_try_again" msgid="8117874972945407006">"Coba lagi"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Hapus"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Sentuh sensor"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Letakkan jari Anda di sensor dan angkat setelah merasakan getaran"</string>
    <string name="security_settings_udfps_enroll_start_message" msgid="5032954588171487566">"Letakkan sidik jari rata pada sensor hingga terasa getaran"</string>
    <string name="security_settings_sfps_enroll_start_message" msgid="9054672627477685212">"Tanpa menekan tombol, tempelkan sidik jari pada sensor sampai Anda merasakan getaran.\n\nGerakkan jari sedikit setiap kali getaran terasa. Tindakan ini membantu merekam sidik jari Anda secara lebih menyeluruh."</string>
    <string name="security_settings_fingerprint_enroll_udfps_title" msgid="6665610134560896895">"Sentuh lama sensor sidik jari"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Angkat jari, lalu sentuhkan lagi"</string>
    <string name="security_settings_udfps_enroll_title_one_more_time" msgid="424937043843482410">"Sekali lagi"</string>
    <string name="security_settings_udfps_enroll_repeat_title_touch_icon" msgid="4096344864386190335">"Ikuti ikon sidik jari"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Angkat dan sentuhkan jari secara berulang untuk menambahkan bagian lain dari sidik jari Anda"</string>
    <string name="security_settings_udfps_enroll_repeat_message" msgid="2213106975297867798">"Sentuh lama setiap kali ikon sidik jari berpindah. Tindakan ini membantu mengambil sidik jari Anda secara lebih menyeluruh."</string>
    <string name="security_settings_udfps_enroll_fingertip_title" msgid="4123142574168831116">"Posisikan ujung jari pada sensor"</string>
    <string name="security_settings_udfps_enroll_left_edge_title" msgid="1944076382202470458">"Posisikan bagian tepi kiri jari"</string>
    <string name="security_settings_udfps_enroll_right_edge_title" msgid="9036744264606447490">"Posisikan bagian tepi kanan jari"</string>
    <string name="security_settings_sfps_enroll_finger_center_title" msgid="1320688855767675739">"Posisikan bagian tengah jari Anda pada sensor"</string>
    <string name="security_settings_sfps_enroll_fingertip_title" msgid="2737520837684516446">"Posisikan ujung jari pada sensor"</string>
    <string name="security_settings_sfps_enroll_left_edge_title" msgid="9022963735924413343">"Posisikan tepi kiri jari Anda pada sensor"</string>
    <string name="security_settings_sfps_enroll_right_edge_title" msgid="823106857743394392">"Terakhir, posisikan tepi kanan jari Anda pada sensor"</string>
    <string name="security_settings_udfps_enroll_edge_message" msgid="4455253923746607702">"Posisikan sisi sidik jari Anda pada sensor, kemudian tahan, lalu beralihlah ke sisi lainnya"</string>
    <string name="security_settings_udfps_enroll_repeat_a11y_message" msgid="2785464357615568197">"Tindakan ini membantu mengambil sidik jari Anda secara lebih menyeluruh"</string>
    <string name="security_settings_sfps_enroll_progress_a11y_message" msgid="6450772721691523736">"Mendaftarkan sidik jari <xliff:g id="PERCENTAGE">%d</xliff:g> persen"</string>
    <string name="security_settings_sfps_animation_a11y_label" msgid="8808819903730940446">"Terdaftar <xliff:g id="PERCENTAGE">%d</xliff:g> persen"</string>
    <string name="security_settings_udfps_enroll_progress_a11y_message" msgid="6183535114682369699">"Mendaftarkan sidik jari <xliff:g id="PERCENTAGE">%d</xliff:g> persen"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Sidik jari ditambahkan"</string>
    <string name="security_settings_require_screen_on_to_auth_title" msgid="1641621458536715518">"Sentuh untuk membuka kunci kapan saja"</string>
    <string name="security_settings_require_screen_on_to_auth_description" msgid="4158414711168345398">"Sentuh sensor untuk membuka kunci, bahkan saat layar nonaktif. Hal ini meningkatkan kemungkinan kunci tidak sengaja dibuka."</string>
    <string name="security_settings_require_screen_on_to_auth_keywords" msgid="5557869560397089603">"Layar, Buka kunci"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Lakukan nanti"</string>
    <string name="security_settings_udfps_tip_fingerprint_help" msgid="7580784640741217494">"Angkat jari, lalu sentuhkan lagi"</string>
    <string name="security_settings_udfps_side_fingerprint_help" msgid="2567232481013195191">"Posisikan sisi sidik jari Anda pada sensor, kemudian tahan, lalu beralihlah ke sisi lainnya"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"Lewati penyiapan sidik jari?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"Anda telah memilih untuk menggunakan sidik jari sebagai satu cara untuk membuka kunci perangkat. Jika dilewati sekarang, Anda harus menyiapkannya nanti. Penyiapan hanya memerlukan waktu sekitar satu menit."</string>
    <string name="lock_screen_skip_setup_title" msgid="6979006375138175111">"Lewati penyiapan untuk <xliff:g id="OPTIONS">%s</xliff:g>?"</string>
    <string name="lock_screen_pin_skip_title" msgid="6853866579893458111">"Lewati penyiapan PIN?"</string>
    <string name="lock_screen_pin_skip_face_title" msgid="8810770395309512358">"Lewati penyiapan PIN dan wajah?"</string>
    <string name="lock_screen_pin_skip_fingerprint_title" msgid="371214283158750976">"Lewati penyiapan PIN dan sidik jari?"</string>
    <string name="lock_screen_pin_skip_biometrics_title" msgid="1082066572914073311">"Lewati penyiapan PIN, wajah, dan sidik jari?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Lewati penyiapan sandi?"</string>
    <string name="lock_screen_password_skip_face_title" msgid="8166210519462164998">"Lewati penyiapan sandi dan wajah?"</string>
    <string name="lock_screen_password_skip_fingerprint_title" msgid="2506392546016772170">"Lewati penyiapan sandi dan sidik jari?"</string>
    <string name="lock_screen_password_skip_biometrics_title" msgid="900281322095862009">"Lewati penyiapan sandi, wajah, dan sidik jari?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Lewati penyiapan pola?"</string>
    <string name="lock_screen_pattern_skip_face_title" msgid="145100333454316334">"Lewati penyiapan pola dan wajah?"</string>
    <string name="lock_screen_pattern_skip_fingerprint_title" msgid="2513110208722100495">"Lewati penyiapan pola dan sidik jari?"</string>
    <string name="lock_screen_pattern_skip_biometrics_title" msgid="2434258106825380187">"Lewati penyiapan pola, wajah, dan sidik jari?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Siapkan kunci layar"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Selesai"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Ups, bukan itu sensornya"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Sentuh sensor di bagian belakang ponsel. Gunakan jari telunjuk Anda."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_dialog_title" msgid="6305457126747942642">"Tidak bisa menyelesaikan penyiapan sidik jari"</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message_setup" msgid="2735739618722623980">"Anda dapat mencoba lagi sekarang atau menyiapkan sidik jari nanti di Setelan."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message" msgid="5858386244898601003">"Anda dapat mencoba lagi sekarang atau menyiapkan sidik jari nanti."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="8582267776559099046">"Waktu penyiapan sidik jari habis"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message_setup" msgid="8521566666541069383">"Anda dapat menyiapkan sidik jari Anda nanti di Setelan."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message_setup" msgid="8140162986046783546">"Terjadi error. Anda dapat menyiapkan sidik jari Anda nanti di Setelan."</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="3534341971920335247">"Anda dapat menyiapkan sidik jari Anda nanti."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="4344665784935791640">"Terjadi error. Anda dapat menyiapkan sidik jari Anda nanti."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Tambahkan lainnya"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Berikutnya"</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_1" msgid="294529888220959309">"Opsi kunci layar dinonaktifkan. Untuk mempelajari lebih lanjut, hubungi admin organisasi Anda."</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_2" msgid="8070829069640846543">"Anda tetap dapat menggunakan sidik jari untuk mengizinkan pembelian dan akses aplikasi."</string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Angkat jari, lalu sentuh sensor lagi"</string>
    <string name="security_settings_fingerprint_bad_calibration_title" msgid="3073145395701953620">"Tidak dapat menggunakan sensor sidik jari"</string>
    <string name="security_settings_fingerprint_bad_calibration" msgid="304585658839584958">"Kunjungi penyedia reparasi."</string>
    <string name="security_advanced_settings" msgid="6260756619837834042">"Setelan keamanan lainnya"</string>
    <string name="security_advanced_settings_work_profile_settings_summary" msgid="7295451997961973175">"Kunci profil kerja, enkripsi, dan lainnya"</string>
    <string name="security_advanced_settings_no_work_profile_settings_summary" msgid="345336447137417638">"Enkripsi, kredensial, dan lainnya"</string>
    <string name="security_advanced_settings_keywords" msgid="5294945170370974974">"keamanan, setelan keamanan lainnya, setelan lainnya, setelan keamanan lanjutan"</string>
    <string name="privacy_advanced_settings" msgid="8828215456566937719">"Setelan privasi lainnya"</string>
    <string name="more_security_privacy_settings" msgid="123465614090328851">"Keamanan &amp; privasi lainnya"</string>
    <string name="security_header" msgid="961514795852103424">"Keamanan"</string>
    <string name="privacy_header" msgid="5526002421324257007">"Privasi"</string>
    <string name="work_profile_category_header" msgid="85707750968948517">"Profil kerja"</string>
    <string name="fingerprint_add_max" msgid="8639321019299347447">"Anda dapat menambahkan maksimal <xliff:g id="COUNT">%d</xliff:g> sidik jari"</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Anda telah menambahkan jumlah maksimum sidik jari"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Tidak dapat menambahkan sidik jari lagi"</string>
    <string name="fingerprint_delete_title" msgid="5412123164503407098">"Hapus \'<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>\'"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="4104208067277655068">"Anda tidak akan dapat menggunakan sidik jari untuk membuka kunci profil kerja, menyetujui pembelian, atau login ke aplikasi kerja."</string>
    <string name="encryption_settings_title" msgid="2848716008695618360">"Enkripsi"</string>
    <string name="encrypted_summary" msgid="545623487587251207">"Dienkripsi"</string>
    <string name="no_screen_lock_issue_title" msgid="1814109590692792891">"Setel kunci layar"</string>
    <string name="no_screen_lock_issue_summary" msgid="2383217853510608406">"Untuk keamanan tambahan, setel PIN, pola, atau sandi untuk perangkat ini."</string>
    <string name="no_screen_lock_issue_action_label" msgid="2691229130486382863">"Setel kunci layar"</string>
    <string name="no_screen_lock_issue_notification_title" msgid="1214876733592830628">"Setel kunci layar"</string>
    <string name="no_screen_lock_issue_notification_text" msgid="8696194459170873345">"Untuk keamanan tambahan, setel PIN, pola, atau sandi untuk perangkat ini."</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Amankan ponsel Anda"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Tambahkan sidik jari untuk membuka kunci"</string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Pilih kunci layar"</string>
    <string name="lock_settings_picker_new_lock_title" msgid="3113042086804290919">"Pilih kunci layar"</string>
    <string name="lock_settings_picker_update_lock_title" msgid="536853138943415927">"Pilih kunci layar baru"</string>
    <string name="lock_settings_picker_new_profile_lock_title" msgid="2270462215256413800">"Pilih kunci untuk aplikasi profil kerja"</string>
    <string name="lock_settings_picker_update_profile_lock_title" msgid="5929068163516308927">"Pilih kunci profil kerja baru"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Untuk keamanan tambahan, setel kunci layar cadangan"</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Pilih metode kunci layar cadangan"</string>
    <string name="lock_settings_picker_admin_restricted_personal_message" msgid="3532653662159888328">"Jika Anda lupa kunci layar, admin IT tidak dapat meresetnya."</string>
    <string name="lock_settings_picker_admin_restricted_personal_message_action" msgid="5956615234246626264">"Setel kunci tersendiri untuk profil kerja"</string>
    <string name="lock_settings_picker_profile_message" msgid="9142379549980873478">"Jika lupa kunci ini, minta Admin IT Anda untuk meresetnya"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Opsi kunci layar"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Opsi kunci layar"</string>
    <string name="lock_screen_auto_pin_confirm_title" msgid="3012128112186088375">"Konfirmasi otomatis untuk membuka kunci"</string>
    <string name="lock_screen_auto_pin_confirm_summary" msgid="9050818870806580819">"Otomatis membuka kunci jika Anda memasukkan PIN 6 digit atau lebih dengan benar. Cara ini agak kurang aman dibandingkan mengetuk Enter untuk mengonfirmasi."</string>
    <string name="auto_pin_confirm_user_message" msgid="6194556173488939314">"Konfirmasi otomatis PIN yang benar"</string>
    <string name="auto_pin_confirm_opt_in_security_message" msgid="580773976736184893">"Mengonfirmasi PIN Anda dengan mengetuk Enter lebih aman daripada menggunakan konfirmasi otomatis"</string>
    <string name="auto_confirm_on_pin_verify_description" msgid="2052240431173223502">"Masukkan PIN perangkat untuk mengaktifkan konfirmasi otomatis"</string>
    <string name="auto_confirm_off_pin_verify_description" msgid="4256219155659760047">"Masukkan PIN perangkat untuk menonaktifkan konfirmasi otomatis"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Kunci layar"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Kunci profil kerja"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Tidak ada"</string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Geser"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Pola"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"PIN"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Sandi"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Jangan sekarang"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Kunci layar saat ini"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="2229689425933043901">"Pola • Sidik jari"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="7979848492740627674">"PIN • Sidik jari"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="6207676267295036963">"Sandi • Sidik jari"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Lanjutkan tanpa sidik jari"</string>
    <string name="face_unlock_set_unlock_pattern" msgid="4206669838203096608">"Pola • Wajah"</string>
    <string name="face_unlock_set_unlock_pin" msgid="9034912683791069602">"PIN • Wajah"</string>
    <string name="face_unlock_set_unlock_password" msgid="5874950853246424756">"Sandi • Wajah"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Lanjutkan tanpa Buka dengan Wajah"</string>
    <string name="biometrics_unlock_set_unlock_pattern" msgid="8084495264354847044">"Pola • Wajah • Sidik jari"</string>
    <string name="biometrics_unlock_set_unlock_pin" msgid="5912980580857825894">"PIN • Wajah • Sidik jari"</string>
    <string name="biometrics_unlock_set_unlock_password" msgid="4612217647465743624">"Sandi • Wajah • Sidik jari"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7785643433551409223">"Lanjutkan tanpa wajah atau sidik jari"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Tidak ada"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Geser"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Pola"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Sandi"</string>
    <string name="unlock_disable_frp_warning_title" msgid="3606280046362811229">"Hapus kunci layar?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"Hapus perlindungan profil?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="6246242612158828147">"Pola melindungi ponsel Anda jika hilang atau dicuri"</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2259825377085781801">"Pola melindungi ponsel Anda jika hilang atau dicuri.<xliff:g id="EMPTY_LINE">

</xliff:g>Pola ini juga menghapus model sidik jari yang disimpan di perangkat. Anda tidak akan dapat menggunakan sidik jari Anda untuk autentikasi dalam aplikasi."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face" msgid="4699508435412336378">"Pola melindungi ponsel Anda jika hilang atau dicuri.<xliff:g id="EMPTY_LINE">

</xliff:g>Model wajah Anda juga akan dihapus secara permanen dan aman. Anda tidak akan dapat menggunakan wajah Anda untuk autentikasi dalam aplikasi."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face_fingerprint" msgid="7049706229344804972">"Pola melindungi ponsel Anda jika hilang atau dicuri.<xliff:g id="EMPTY_LINE">

</xliff:g>Pola ini menghapus model sidik jari yang disimpan di perangkat. Model wajah Anda juga akan dihapus secara permanen dan aman. Anda tidak akan dapat menggunakan wajah atau sidik jari Anda untuk autentikasi dalam aplikasi."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="122154942944422284">"PIN melindungi ponsel Anda jika hilang atau dicuri"</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="983373874470746066">"PIN melindungi ponsel Anda jika hilang atau dicuri.<xliff:g id="EMPTY_LINE">

</xliff:g>Tindakan ini juga menghapus model sidik jari yang disimpan di perangkat. Anda tidak akan dapat menggunakan sidik jari Anda untuk autentikasi dalam aplikasi."</string>
    <string name="unlock_disable_frp_warning_content_pin_face" msgid="5607150515413131761">"PIN melindungi ponsel Anda jika hilang atau dicuri.<xliff:g id="EMPTY_LINE">

</xliff:g>Model wajah Anda juga akan dihapus secara permanen dan aman. Anda tidak akan dapat menggunakan wajah Anda untuk autentikasi dalam aplikasi."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint" msgid="1821792325159866312">"PIN melindungi ponsel Anda jika hilang atau dicuri.<xliff:g id="EMPTY_LINE">

</xliff:g>PIN ini menghapus model sidik jari yang disimpan di perangkat. Model wajah Anda juga akan dihapus secara permanen dan aman. Anda tidak akan dapat menggunakan wajah atau sidik jari Anda untuk autentikasi dalam aplikasi."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="6422723907917376210">"Sandi melindungi ponsel Anda jika hilang atau dicuri"</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8899452884016354856">"Sandi melindungi ponsel Anda jika hilang atau dicuri.<xliff:g id="EMPTY_LINE">

</xliff:g>Sandi ini juga menghapus model sidik jari yang disimpan di perangkat. Anda tidak akan dapat menggunakan sidik jari Anda untuk autentikasi dalam aplikasi."</string>
    <string name="unlock_disable_frp_warning_content_password_face" msgid="1811067332335964495">"Sandi melindungi ponsel Anda jika hilang atau dicuri.<xliff:g id="EMPTY_LINE">

</xliff:g>Model wajah Anda juga akan dihapus secara permanen dan aman. Anda tidak akan dapat menggunakan wajah Anda untuk autentikasi dalam aplikasi."</string>
    <string name="unlock_disable_frp_warning_content_password_face_fingerprint" msgid="7063649456205159491">"Sandi melindungi ponsel Anda jika hilang atau dicuri.<xliff:g id="EMPTY_LINE">

</xliff:g>Sandi ini menghapus model sidik jari yang disimpan di perangkat. Model wajah Anda juga akan dihapus secara permanen dan aman. Anda tidak akan dapat menggunakan wajah atau sidik jari Anda untuk autentikasi dalam aplikasi."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Fitur perlindungan perangkat tidak akan berfungsi tanpa kunci layar."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="6542744110902941189">"Fitur perlindungan perangkat tidak akan berfungsi tanpa kunci layar.<xliff:g id="EMPTY_LINE">

</xliff:g>Fitur perlindungan perangkat ini juga menghapus model sidik jari yang disimpan di perangkat. Anda tidak akan dapat menggunakan sidik jari Anda untuk autentikasi dalam aplikasi."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face" msgid="4559917661432267841">"Fitur perlindungan perangkat tidak akan berfungsi tanpa kunci layar.<xliff:g id="EMPTY_LINE">

</xliff:g>Model wajah Anda juga akan dihapus secara permanen dan aman. Anda tidak akan dapat menggunakan wajah Anda untuk autentikasi dalam aplikasi."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face_fingerprint" msgid="3779582301453677644">"Fitur perlindungan perangkat tidak akan berfungsi tanpa kunci layar.<xliff:g id="EMPTY_LINE">

</xliff:g>Fitur perlindungan perangkat ini menghapus model sidik jari yang disimpan di perangkat. Model wajah Anda juga akan dihapus secara permanen dan aman. Anda tidak akan dapat menggunakan wajah atau sidik jari Anda untuk autentikasi dalam aplikasi."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="6173427638951230842">"Hapus"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"<xliff:g id="APP_NAME">%1$s</xliff:g> merekomendasikan PIN atau sandi yang kuat, dan mungkin tidak berfungsi seperti yang diharapkan tanpa salah satunya"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"<xliff:g id="APP_NAME">%1$s</xliff:g> merekomendasikan PIN atau sandi baru, dan mungkin tidak berfungsi seperti yang diharapkan tanpa salah satunya"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"<xliff:g id="APP_NAME">%1$s</xliff:g> merekomendasikan pola, PIN, atau sandi baru, dan mungkin tidak berfungsi seperti yang diharapkan tanpa salah satunya"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"<xliff:g id="APP_NAME">%1$s</xliff:g> merekomendasikan kunci layar baru"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"Coba lagi. Upaya ke-<xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g> dari maksimal <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g> kali."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="7450322567217745999">"Data akan dihapus"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"Jika Anda memasukkan pola yang salah saat mencoba lagi, data perangkat ini akan dihapus"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"Jika Anda memasukkan PIN yang salah saat mencoba lagi, data perangkat ini akan dihapus"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"Jika Anda memasukkan sandi yang salah saat mencoba lagi, data perangkat ini akan dihapus"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"Jika Anda memasukkan pola yang salah saat mencoba lagi, pengguna ini akan dihapus"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"Jika Anda memasukkan PIN yang salah saat mencoba lagi, pengguna ini akan dihapus"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"Jika Anda memasukkan sandi yang salah saat mencoba lagi, pengguna ini akan dihapus"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"Jika Anda memasukkan pola yang salah saat mencoba lagi, profil kerja dan datanya akan dihapus"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Jika Anda memasukkan PIN yang salah saat mencoba lagi, profil kerja dan datanya akan dihapus"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Jika Anda memasukkan sandi yang salah saat mencoba lagi, profil kerja dan datanya akan dihapus"</string>
    <string name="lockpassword_password_too_short" msgid="1938086368137797700">"{count,plural, =1{Harus berisi minimal # karakter}other{Harus berisi minimal # karakter}}"</string>
    <string name="lockpassword_password_too_short_all_numeric" msgid="4301294924022401502">"{count,plural, =1{Perlu minimal 1 digit jika hanya menggunakan angka}other{Perlu minimal # digit jika hanya menggunakan angka}}"</string>
    <string name="lockpassword_pin_too_short" msgid="8910105226463085689">"{count,plural, =1{PIN harus berisi minimal # digit}other{PIN harus berisi minimal # digit}}"</string>
    <string name="lockpassword_pin_too_short_autoConfirm_extra_message" msgid="3271351502900762571">"{count,plural, =1{PIN harus berisi minimal # digit, tetapi sebaiknya gunakan PIN {minAutoConfirmLen} digit agar lebih aman}other{PIN harus berisi minimal # digit, tetapi sebaiknya gunakan PIN {minAutoConfirmLen} digit agar lebih aman}}"</string>
    <string name="lockpassword_password_too_long" msgid="1940345313260498308">"{count,plural, =1{Harus kurang dari # karakter}other{Harus kurang dari # karakter}}"</string>
    <string name="lockpassword_pin_too_long" msgid="1678212054564388576">"{count,plural, =1{Harus kurang dari # digit}other{Harus kurang dari # digit}}"</string>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"Admin perangkat tidak mengizinkan penggunaan PIN terbaru."</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"Tidak boleh berisi karakter yang tidak valid"</string>
    <string name="lockpassword_password_requires_letters" msgid="7058340182953750553">"{count,plural, =1{Harus berisi minimal 1 huruf}other{Harus berisi minimal # huruf}}"</string>
    <string name="lockpassword_password_requires_lowercase" msgid="3286121470522077547">"{count,plural, =1{Harus berisi minimal 1 huruf kecil}other{Harus berisi minimal # huruf kecil}}"</string>
    <string name="lockpassword_password_requires_uppercase" msgid="720312543910397772">"{count,plural, =1{Harus berisi minimal 1 huruf besar}other{Harus berisi minimal # huruf besar}}"</string>
    <string name="lockpassword_password_requires_numeric" msgid="3886918493600507548">"{count,plural, =1{Harus berisi minimal 1 digit angka}other{Harus berisi minimal # digit angka}}"</string>
    <string name="lockpassword_password_requires_symbols" msgid="2904870551002210131">"{count,plural, =1{Harus berisi minimal 1 simbol khusus}other{Harus berisi minimal # simbol khusus}}"</string>
    <string name="lockpassword_password_requires_nonletter" msgid="1185342065898300006">"{count,plural, =1{Harus berisi minimal 1 karakter bukan huruf}other{Harus berisi minimal # karakter bukan huruf}}"</string>
    <string name="lockpassword_password_requires_nonnumerical" msgid="389687423482993365">"{count,plural, =1{Harus berisi minimal 1 karakter bukan angka}other{Harus berisi minimal # karakter bukan angka}}"</string>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"Admin perangkat tidak mengizinkan penggunaan sandi terbaru."</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Urutan digit naik, turun, atau berulang tidak diizinkan"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Konfirmasi"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Hapus"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Kunci layar sudah diganti Coba lagi dengan kunci layar yang baru."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Batal"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Selanjutnya"</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Aplikasi admin perangkat"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"Tidak ada aplikasi aktif"</string>
    <string name="number_of_device_admins" msgid="3402909995362162876">"{count,plural, =1{# aplikasi aktif}other{# aplikasi aktif}}"</string>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Agen tepercaya"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Untuk menggunakannya, setel kunci layar terlebih dahulu"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Tidak ada"</string>
    <string name="manage_trust_agents_summary_on" msgid="3302574418419446146">"{count,plural, =1{1 agen tepercaya aktif}other{# agen tepercaya aktif}}"</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">"Sambungkan dengan <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_group_late_bonding" msgid="5310869364570266209">"Tambahkan anggota baru ke kumpulan perangkat terkoordinasi yang ada"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Kode penyambungan Bluetooth"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Ketik kode penyandingan lalu tekan Kembali atau Enter"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"PIN berisi huruf atau simbol"</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Biasanya 0000 atau 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Harus berisi 18 digit"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Anda mungkin juga perlu mengetikkan PIN ini ke perangkat lain."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Anda mungkin juga perlu mengetikkan sandi ini ke perangkat lain."</string>
    <string name="bluetooth_paring_group_msg" msgid="4609515924670823316">"Konfirmasikan agar dapat tersambung dengan kumpulan perangkat terkoordinasi"</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Izinkan akses ke kontak dan histori panggilan Anda"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Tidak dapat terhubung ke <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Perangkat yang tersedia"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Hubungkan"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Putuskan koneksi"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Sambungkan &amp; hubungkan"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="316627049372961941">"Saat Bluetooth aktif, perangkat dapat berkomunikasi dengan perangkat Bluetooth terdekat lainnya."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="786648535600075223">"Jika Bluetooth diaktifkan, perangkat Anda dapat berkomunikasi dengan perangkat Bluetooth di sekitar.\n\nUntuk meningkatkan fungsi perangkat, aplikasi dan layanan tetap dapat memindai perangkat di sekitar kapan saja, bahkan saat Bluetooth nonaktif. Setelan ini dapat digunakan, misalnya, untuk meningkatkan kualitas fitur dan layanan berbasis lokasi. Anda dapat mengubahnya di setelan pemindaian Bluetooth."</string>
    <string name="bluetooth_scan_change" msgid="1744636222637390367">"Ubah"</string>
    <string name="device_details_title" msgid="1155622417516195481">"Detail perangkat"</string>
    <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"Setelan keyboard"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Alamat Bluetooth perangkat: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_multuple_devices_mac_address" msgid="4974301550897923376">"Alamat Bluetooth perangkat:\n<xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"Lupakan perangkat?"</string>
    <string name="remove_association_button" msgid="5004208145998061135">"Hapus atribusi"</string>
    <string name="bluetooth_companion_app_remove_association_dialog_title" msgid="1344518601377991897">"Putuskan Koneksi Aplikasi?"</string>
    <string name="bluetooth_companion_app_body" msgid="8442643629075687761">"Aplikasi <xliff:g id="APP_NAME">%1$s</xliff:g> tidak akan lagi terhubung ke <xliff:g id="DEVICE_NAME">%2$s</xliff:g> Anda"</string>
    <string name="device_details_leaudio_toggle_summary" msgid="7684848254433230809">"Eksperimental. Meningkatkan kualitas audio."</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Lupakan perangkat"</string>
    <string name="bluetooth_companion_app_remove_association_confirm_button" msgid="76323555527926915">"Putuskan koneksi aplikasi"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Jumlah maksimum perangkat audio Bluetooth yang terhubung"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Pilih jumlah maksimum perangkat audio Bluetooth yang terhubung"</string>
    <string name="nfc_stack_debuglog_title" msgid="2926748386805740609">"Log debug stack NFC"</string>
    <string name="nfc_stack_debuglog_summary" msgid="7333205107551132121">"Tingkatkan level logging stack NFC"</string>
    <string name="nfc_verbose_vendor_log_title" msgid="5554505631122964628">"Log debug vendor panjang NFC"</string>
    <string name="nfc_verbose_vendor_log_summary" msgid="3049128322855928507">"Sertakan log vendor tambahan khusus perangkat dalam laporan bug, yang mungkin berisi informasi pribadi."</string>
    <string name="nfc_snoop_log_title" msgid="1576197495976952388">"Log tanpa filter NCI NFC"</string>
    <string name="nfc_snoop_log_summary" msgid="3988383328800163180">"Catat paket NFC detail, yang mungkin berisi informasi pribadi."</string>
    <string name="nfc_reboot_dialog_title" msgid="2033983438635768169">"Mulai Ulang Perangkat?"</string>
    <string name="nfc_reboot_dialog_message" msgid="4929353168157966992">"Pencatatan log NFC detail dimaksudkan hanya untuk tujuan pengembangan. Data NFC tambahan disertakan dalam laporan bug, yang mungkin berisi informasi pribadi. Mulai ulang perangkat untuk mengubah setelan ini."</string>
    <string name="nfc_reboot_dialog_confirm" msgid="4769763632008584567">"Mulai ulang"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Transmisi"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"cermin"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Aktifkan layar nirkabel"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"Tidak ditemukan perangkat di sekitar."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Menghubungkan"</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Terhubung"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"Sedang digunakan"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Tidak tersedia"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Opsi layar nirkabel"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Lupakan"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Selesai"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Nama"</string>
    <string name="wifi_band_24ghz" msgid="7322286660245127384">"2,4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="7995204987245404797">"5 GHz"</string>
    <string name="wifi_band_6ghz" msgid="8166833829829455339">"6 GHz"</string>
    <string name="wifi_sign_in_button_text" msgid="8483892122845654850">"Login"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Buka situs"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"<xliff:g id="REMAINING_TIME">%1$s</xliff:g> lagi"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Berakhir pada <xliff:g id="EXPIRY_TIME">%1$s</xliff:g>"</string>
    <string name="tx_link_speed" msgid="3071955184703668113">"<xliff:g id="TRANSMIT_LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="rx_link_speed" msgid="6292229178855567783">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="link_speed" msgid="931786745741016446">"<xliff:g id="LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="wifi_ask_enable" msgid="6860056048266810769">"<xliff:g id="REQUESTER">%s</xliff:g> ingin mengaktifkan Wi-Fi"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"<xliff:g id="REQUESTER">%s</xliff:g> ingin menonaktifkan Wi-Fi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Verifikasi bytecode aplikasi yang dapat di-debug"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Izinkan ART memverifikasi bytecode untuk aplikasi yang dapat di-debug"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Tampilkan kecepatan refresh"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Tampilkan kecepatan refresh layar saat ini"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Wajib buka kunci perangkat untuk NFC"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Siap mentransmisikan konten apl melalui NFC"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Mati"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Tidak tersedia karena NFC nonaktif"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"Jika fitur ini diaktifkan, Anda dapat membagikan konten aplikasi lewat beaming ke perangkat lain yang mendukung NFC, yaitu dengan saling menempelkan perangkat. Anda dapat membagikan halaman web, video YouTube, kontak, dan lainnya.\n\nCukup tempelkan perangkat (biasanya saling membelakangi), lalu ketuk layar. Konten yang dibagikan secara beaming bergantung pada aplikasi."</string>
    <string name="wifi_settings" msgid="8313301946393559700">"Wi‑Fi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"Gunakan Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"Setelan Wi-Fi"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Pilih Wi-Fi"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"Menyalakan Wi-Fi..."</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"Mematikan Wi-Fi..."</string>
    <string name="wifi_error" msgid="4903954145386086899">"Kesalahan"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"Pita frekuensi 5 GHz tidak tersedia di negara ini"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"Dalam mode Pesawat"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Beri tahu untuk jaringan publik"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Beri tahu ketika jaringan publik berkualitas tinggi tersedia"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Otomatis aktifkan Wi‑Fi"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"Wi‑Fi akan aktif kembali di dekat jaringan berkualitas tinggi yang tersimpan, seperti jaringan rumah Anda"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Tidak tersedia karena lokasi dinonaktifkan. Aktifkan "<annotation id="link">"lokasi"</annotation>"."</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Instal sertifikat"</string>
    <string name="wifi_scan_notify_text" msgid="7163137260385995873">"Untuk meningkatkan akurasi lokasi, aplikasi dan layanan masih dapat memindai jaringan Wi-Fi kapan saja, meski Wi-Fi nonaktif. Ini dapat digunakan, misalnya, untuk meningkatkan fitur dan layanan berbasis lokasi. Anda dapat mengubahnya di <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>setelan pemindaian Wi‑Fi<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="7439201783168213149">"Untuk meningkatkan akurasi lokasi, aktifkan pemindaian Wi-Fi di <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>setelan pemindaian Wi-Fi<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Beralih ke data seluler secara otomatis"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Gunakan data seluler saat Wi-Fi tidak memiliki akses internet. Mungkin dikenakan biaya penggunaan data."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Tambahkan jaringan"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"Preferensi Wi‑Fi"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"Wi‑Fi kembali aktif secara otomatis"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"Wi‑Fi tidak aktif kembali secara otomatis"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"Wi‑Fi Langsung"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Aktifkan Wi-Fi untuk melihat jaringan yang ada."</string>
    <string name="wifi_empty_list_wifi_on" msgid="2448010040478321376">"Mencari jaringan …"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Anda tidak memiliki izin untuk mengubah jaringan Wi‑Fi."</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Aktifkan pemindaian Wi-Fi?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"Untuk mengaktifkan Wi-Fi secara otomatis, Anda harus mengaktifkan pemindaian Wi-Fi terlebih dahulu."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"Pemindaian Wi-Fi memungkinkan aplikasi dan layanan untuk memindai jaringan Wi-Fi kapan saja, meski Wi-Fi nonaktif. Ini dapat dilakukan, misalnya, untuk meningkatkan kualitas fitur dan layanan berbasis lokasi."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Aktifkan"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"Pemindaian Wi-Fi diaktifkan"</string>
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Opsi lanjutan"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Menu drop-down Opsi Lanjutan"</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"luaskan"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Nama jaringan"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Masukkan SSID"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Keamanan"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Jaringan tersembunyi"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"Jika router tidak menyiarkan ID jaringan, tetapi Anda ingin menghubungkannya pada masa mendatang, Anda dapat menyetel jaringan sebagai tersembunyi.\n\nTindakan ini dapat menyebabkan risiko keamanan karena ponsel secara berkala akan menyiarkan sinyal untuk menemukan jaringan.\n\nMenyetel jaringan sebagai tersembunyi tidak akan mengubah setelan router."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Kekuatan sinyal"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Status"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Kecepatan pengiriman link"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Kecepatan penerimaan link"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Kecepatan link"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Frekuensi"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"Alamat IP"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Disimpan melalui"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"Kredensial <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"Metode EAP"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"Autentikasi tahap 2"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"Sertifikat CA"</string>
    <string name="wifi_eap_min_tls_ver" msgid="174023604103299457">"Versi TLS minimum"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Status Sertifikat Online"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Domain"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Sertifikat pengguna"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Identitas"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Identitas anonim"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Sandi"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Tampilkan sandi"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"Band 2,4 GHz"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"Disarankan Band 5.0 GHz"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"Setelan IP"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Privasi"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Langganan"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Melihat atau mengubah langganan"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Randomized MAC"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Tambahkan perangkat"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Pusatkan kode QR untuk menambahkan perangkat ke “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"Pindai kode QR"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Pusatkan kode QR untuk menyambungkan ke “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Terhubung ke Wi‑Fi dengan memindai kode QR"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"Bagikan Wi‑Fi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Pindai kode QR ini dengan perangkat lain untuk terhubung ke “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Pindai kode QR ini untuk terhubung ke “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Coba lagi. Jika masalah berlanjut, hubungi produsen perangkat"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Ada masalah"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Pastikan perangkat telah dicolokkan, diisi dayanya, dan diaktifkan"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Pastikan perangkat telah dicolokkan, diisi dayanya, dan diaktifkan. Jika masalah berlanjut, hubungi produsen perangkat"</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"Penambahan “<xliff:g id="SSID">%1$s</xliff:g>” tidak didukung oleh perangkat ini"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Coba pindahkan perangkat lebih dekat ke titik akses/router Wi-Fi"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Periksa sandi dan coba lagi"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Hubungi produsen perangkat"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Periksa koneksi dan coba lagi"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Pilih jaringan"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Untuk menyambungkan perangkat Anda, pilih jaringan"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Tambahkan perangkat ini ke “<xliff:g id="SSID">%1$s</xliff:g>”?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"Wi‑Fi dibagikan dengan perangkat"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Tambahkan perangkat lain"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Pilih jaringan lainnya"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Tidak dapat menambahkan perangkat"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Perangkat ditemukan"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"Membagikan Wi‑Fi kepada perangkat ini…"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Menyambungkan…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Bagikan hotspot"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="4231438175617953652">"Verifikasi bahwa ini adalah Anda"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"Sandi Wi‑Fi: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Sandi hotspot: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Hubungkan otomatis"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Izinkan koneksi ke jaringan ini saat berada dalam jangkauan"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Tambahkan perangkat"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Gunakan kode QR untuk menambahkan perangkat ke jaringan ini"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"Format kode QR tidak valid"</string>
    <string name="retry" msgid="7542103800274026915">"Coba lagi"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Berbagi dengan pengguna perangkat lain"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(tidak diubah)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Pilih"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(Beberapa sertifikat ditambahkan)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Gunakan sertifikat sistem"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Jangan berikan"</string>
    <string name="wifi_trust_on_first_use" msgid="7488431582505858774">"Percayai pada penggunaan pertama"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Nama jaringan terlalu panjang."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Domain harus ditentukan."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Sertifikat diwajibkan."</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"Untuk meningkatkan ketepatan lokasi dan untuk tujuan lainnya, <xliff:g id="APP_NAME">%1$s</xliff:g> ingin mengaktifkan pemindaian jaringan, bahkan saat Wi-Fi sedang tidak aktif.\n\nIzinkan ini untuk semua aplikasi yang ingin memindai?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="4903345360745717385">"Untuk meningkatkan akurasi lokasi dan untuk tujuan-tujuan lainnya, sebuah aplikasi yang tidak dikenal ingin mengaktifkan pemindaian jaringan, bahkan saat Wi‑Fi nonaktif.\n\nIzinkan ini untuk semua aplikasi yang ingin memindai?"</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Izinkan"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Tolak"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Jaringan ini tidak memiliki akses internet. Tetap hubungkan?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Beberapa aplikasi dan layanan mungkin tidak berfungsi karena konektivitas terbatas. Tetap gunakan?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"Jangan tanya lagi untuk jaringan ini"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"Wi-Fi tidak terhubung ke internet"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"Anda dapat beralih ke jaringan seluler jika sambungan Wi-Fi buruk. Mungkin dikenai biaya penggunaan data."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Beralih ke seluler"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Tetap di Wi-Fi"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Jangan tampilkan lagi"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Hubungkan"</string>
    <string name="wifi_turned_on_message" msgid="8069855406962662881">"Wi-Fi diaktifkan"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Terhubung ke <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting_to_message" msgid="3153205024060064551">"Menghubungkan ke <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Menyambungkan…"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Gagal menyambung ke jaringan"</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Jaringan di luar jangkauan"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Lupakan"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Ubah"</string>
    <string name="wifi_failed_forget_message" msgid="8272732599235525880">"Gagal melupakan jaringan"</string>
    <string name="wifi_save" msgid="2312643132472226807">"Simpan"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Gagal menyimpan jaringan"</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Batal"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Lupakan jaringan?"</string>
    <string name="wifi_saved_access_points_summary" msgid="6637163320524940353">"{count,plural, =1{1 jaringan}other{# jaringan}}"</string>
    <string name="wifi_saved_passpoint_access_points_summary" msgid="8939933724918673785">"{count,plural, =1{1 langganan}other{# langganan}}"</string>
    <string name="wifi_saved_all_access_points_summary" msgid="2335870101156113858">"{count,plural, =1{1 jaringan &amp; langganan}other{# jaringan &amp; langganan}}"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"Alamat MAC perangkat"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Alamat MAC acak"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Alamat MAC acak (terakhir digunakan)"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Detail jaringan"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Subnet mask"</string>
    <string name="wifi_type_title" msgid="2174893488722015838">"Jenis"</string>
    <string name="wifi_details_dns" msgid="273231528073312579">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="1913151339341722443">"Alamat IPv6"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Jaringan tersimpan"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Langganan"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Jaringan lain"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Ketikkan alamat IP yang valid."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Ketikkan alamat gerbang yang valid."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Ketik alamat DNS yang valid."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Ketikkan panjang awalan jaringan antara 0 dan 32."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS 1 (kecuali jika diganti dengan DNS Pribadi)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS 2 (kecuali jika diganti dengan DNS Pribadi)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Gateway"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Panjang awalan jaringan"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"Wi‑Fi Langsung"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Telusuri perangkat"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Menelusuri…"</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Ganti nama perangkat"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Perangkat P2P"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Grup yang diingat"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Tidak dapat menyambung."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Gagal mengubah nama perangkat."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Putuskan koneksi?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"Jika diputuskan, sambungan Anda dengan <xliff:g id="PEER_NAME">%1$s</xliff:g> akan berakhir."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="4490648217799144078">"Jika diputuskan, sambungan Anda dengan <xliff:g id="PEER_NAME">%1$s</xliff:g> dan <xliff:g id="PEER_COUNT">%2$s</xliff:g> perangkat lain akan berakhir."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="8476985132989357041">"Batalkan undangan?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"Apakah Anda ingin membatalkan undangan untuk terhubung dengan <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="4880242270742385699">"Lupakan grup ini?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"Hotspot Wi‑Fi"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"Tidak berbagi koneksi internet atau konten dengan perangkat lain"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"Sandi tidak disetel"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Nama hotspot"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Sandi hotspot"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="560262446129195042">"AP Band"</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Otomatis nonaktifkan hotspot"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Saat tidak ada perangkat terhubung"</string>
    <string name="wifi_hotspot_maximize_compatibility" msgid="6494125684420024058">"Perluas kompatibilitas"</string>
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary" msgid="383355687431591441">"Membantu perangkat lain menemukan hotspot ini. Mengurangi kecepatan koneksi hotspot."</string>
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary" msgid="3579549223159056533">"Membantu perangkat lain menemukan hotspot ini. Meningkatkan penggunaan baterai."</string>
    <string name="wifi_hotspot_speed_title" msgid="8629448084180512685">"Kecepatan &amp; kompatibilitas"</string>
    <string name="wifi_hotspot_speed_summary_2g" msgid="5063438001736234858">"2,4 GHz/Kompatibel dengan sebagian besar perangkat"</string>
    <string name="wifi_hotspot_speed_summary_5g" msgid="6221158936983135040">"5 GHz/Kompatibel dengan banyak perangkat"</string>
    <string name="wifi_hotspot_speed_summary_6g" msgid="8863992901226595544">"6 GHz/Kompatibel dengan beberapa perangkat"</string>
    <string name="wifi_hotspot_speed_summary_2g_and_5g" msgid="5931052946168943750">"2,4 dan 5 GHz/Kompatibel dengan sebagian besar perangkat"</string>
    <string name="wifi_hotspot_speed_intro" msgid="6973482196363758925">"Pilih frekuensi untuk hotspot Anda. Frekuensi memengaruhi kecepatan koneksi dan jenis perangkat yang dapat menemukan hotspot Anda."</string>
    <string name="wifi_hotspot_speed_category" msgid="5265655850463630286">"Preferensi frekuensi"</string>
    <string name="wifi_hotspot_speed_2g" msgid="3400600834257664480">"2,4 GHz"</string>
    <string name="wifi_hotspot_speed_2g_summary" msgid="6930273933810520155">"Koneksi lebih lambat. Kompatibel dengan sebagian besar perangkat."</string>
    <string name="wifi_hotspot_speed_5g" msgid="4058116867148848395">"5 GHz"</string>
    <string name="wifi_hotspot_speed_5g_summary" msgid="562987935924535694">"Koneksi cepat. Kompatibel dengan banyak perangkat."</string>
    <string name="wifi_hotspot_speed_2g_5g" msgid="9192756255938408285">"2,4 dan 5 GHz"</string>
    <string name="wifi_hotspot_speed_2g_5g_summary" msgid="8104575293617700173">"Koneksi cepat. Hotspot dual band ini kompatibel dengan sebagian besar perangkat."</string>
    <string name="wifi_hotspot_speed_6g" msgid="3787697484862730500">"6 GHz"</string>
    <string name="wifi_hotspot_speed_6g_summary" msgid="8675262219242174548">"Kecepatan tertinggi. Kompatibel dengan beberapa perangkat."</string>
    <string name="wifi_hotspot_speed_summary_unavailable" msgid="7276080644693388756">"Tidak tersedia di negara atau wilayah Anda"</string>
    <string name="wifi_hotspot_speed_footer" msgid="8846939503916795002">"Jika frekuensi pilihan tidak tersedia, hotspot Anda dapat menggunakan frekuensi yang berbeda. Setelan keamanan hotspot dapat berubah jika Anda mengubah frekuensi."</string>
    <string name="wifi_hotspot_security_summary_unavailable" msgid="117582979310345853">"Tidak tersedia dengan 6 GHz"</string>
    <string name="wifi_hotspot_security_footer" msgid="4608329688744949796">"Setelan keamanan dapat berubah jika Anda mengubah frekuensi hotspot"</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Menyalakan hotspot..."</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Mematikan hotspot..."</string>
    <string name="wifi_tether_carrier_unsupport_dialog_title" msgid="3089432578433978073">"Tethering tidak tersedia"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_content" msgid="5920421547607921112">"Hubungi operator untuk mengetahui detailnya"</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> aktif"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"AndroidHotspot"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Simpan jaringan ini?"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Menyimpan…"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Disimpan"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Tidak dapat menyimpan. Coba lagi."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Simpan jaringan?"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Menyimpan <xliff:g id="NUMBER">%d</xliff:g> jaringan…"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Jaringan disimpan"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"Panggilan Wi-Fi"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Perluas panggilan dengan Wi-Fi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Aktifkan panggilan Wi-Fi untuk memperluas jangkauan"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Preferensi panggilan telepon"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Preferensi panggilan telepon"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Preferensi roaming"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Preferensi roaming"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"Wi-Fi"</item>
    <item msgid="8622872038388687383">"Ponsel"</item>
    <item msgid="3027927219952052398">"Khusus Wi-Fi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"Wi-Fi"</item>
    <item msgid="7566603075659706590">"Ponsel"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"Jika Wi-Fi tidak tersedia, gunakan jaringan seluler"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"Jika jaringan seluler tidak tersedia, gunakan Wi-Fi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Telepon melalui Wi-Fi. Jika Wi-Fi terputus, panggilan akan berakhir."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"Jika panggilan Wi-Fi aktif, ponsel dapat mengarahkan panggilan telepon melalui jaringan Wi-Fi atau jaringan operator, bergantung pada preferensi dan sinyal mana yang lebih kuat. Sebelum mengaktifkan fitur ini, sebaiknya tanyakan info biaya dan detail lainnya ke operator.<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">"Alamat darurat"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Digunakan sebagai lokasi Anda ketika Anda melakukan panggilan darurat melalui Wi‑Fi"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Pelajari lebih lanjut"</annotation>" fitur DNS Pribadi"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Aktif"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Aktifkan Panggilan Wi-Fi"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Aktifkan panggilan Wi-Fi"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"Terputus dari <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="sound_settings" msgid="7622986039384531304">"Suara dan getaran"</string>
    <string name="account_settings" msgid="255404935489127404">"Akun"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Akun profil kerja - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Akun profil pribadi"</string>
    <string name="accessibility_category_clone" msgid="7893383448944567885">"Akun profil clone"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Akun kerja - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Akun pribadi - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Telusuri"</string>
    <string name="display_settings" msgid="7197750639709493852">"Layar"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Putar layar otomatis"</string>
    <string name="auto_rotate_option_off" msgid="2788096269396290731">"Nonaktif"</string>
    <string name="auto_rotate_option_on" msgid="5776678230808498171">"Aktif"</string>
    <string name="auto_rotate_option_face_based" msgid="3438645484087953174">"Aktif - Berbasis deteksi wajah"</string>
    <string name="auto_rotate_switch_face_based" msgid="9116123744601564320">"Deteksi Wajah"</string>
    <string name="auto_rotate_link_a11y" msgid="5146188567212233286">"Pelajari putar otomatis lebih lanjut"</string>
    <string name="screen_resolution_title" msgid="2690518693139811486">"Resolusi layar"</string>
    <string name="screen_resolution_option_high" msgid="2617496842852992853">"Resolusi tinggi"</string>
    <string name="screen_resolution_option_full" msgid="2694003735219114186">"Resolusi penuh"</string>
    <string name="screen_resolution_footer" msgid="6772341522952795647">"Resolusi penuh menggunakan lebih banyak daya baterai. Mengganti resolusi dapat menyebabkan beberapa aplikasi dimulai ulang."</string>
    <string name="screen_resolution_selected_a11y" msgid="6158451180032224977">"Dipilih"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Warna"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Alami"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Dipertajam"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Disaturasi"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Adaptif"</string>
    <string name="brightness" msgid="6216871641021779698">"Tingkat kecerahan"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Kecerahan adaptif"</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"Kecerahan layar akan disesuaikan otomatis dengan lingkungan dan aktivitas Anda. Anda dapat memindahkan penggeser secara manual untuk membantu kecerahan adaptif belajar dari preferensi Anda."</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"Aktif"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Nonaktif"</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"White balance layar"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="peak_refresh_rate_title" msgid="1878771412897140903">"Smooth Display"</string>
    <string name="peak_refresh_rate_summary" msgid="3627278682437562787">"Otomatis meningkatkan kecepatan refresh dari 60 menjadi <xliff:g id="ID_1">%1$s</xliff:g> Hz untuk beberapa konten. Meningkatkan penggunaan baterai."</string>
    <string name="force_high_refresh_rate_toggle" msgid="3325789621928312050">"Paksa kecepatan refresh tertinggi"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Kecepatan refresh tertinggi untuk memperbaiki respons sentuhan &amp; kualitas animasi. Meningkatkan penggunaan baterai."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Fokus ke layar"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Perlu akses kamera"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5822591289468803691">"Perlu akses kamera untuk fokus ke layar. Ketuk guna mengelola izin untuk Layanan Personalisasi Perangkat"</string>
    <string name="adaptive_sleep_manage_permission_button" msgid="1404510197847664846">"Kelola izin"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Mencegah layar mati jika Anda sedang melihatnya"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"Fitur fokus ke layar menggunakan kamera depan untuk mengetahui apakah seseorang sedang melihat layar. Fitur ini berjalan di perangkat, dan gambar tidak pernah disimpan atau dikirim ke Google."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Aktifkan fokus ke layar"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Buat layar tetap menyala saat dilihat"</string>
    <string name="auto_rotate_camera_lock_title" msgid="5369003176695105872">"Kamera dikunci"</string>
    <string name="auto_rotate_camera_lock_summary" msgid="5699491516271544672">"Kamera harus dibuka kuncinya untuk Deteksi Wajah"</string>
    <string name="adaptive_sleep_camera_lock_summary" msgid="8417541183603618098">"Kamera harus dibuka kuncinya untuk Fokus ke Layar"</string>
    <string name="auto_rotate_summary_no_permission" msgid="1025061139746254554">"Perlu akses kamera untuk Deteksi Wajah. Ketuk guna mengelola izin untuk Layanan Personalisasi Perangkat"</string>
    <string name="auto_rotate_manage_permission_button" msgid="2591146085906382385">"Kelola izin"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Cahaya Malam"</string>
    <string name="night_display_text" msgid="4789324042428095383">"Cahaya Malam memberikan rona kuning pada layar. Ini membuat Anda lebih mudah melihat layar atau membaca saat cahaya redup, serta membantu Anda lebih mudah tidur."</string>
    <string name="night_display_auto_mode_title" msgid="5869128421470824381">"Jadwal"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Tidak ada"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Aktifkan pada waktu khusus"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Aktifkan dari malam hingga pagi"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Waktu mulai"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Waktu selesai"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intensitas"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Tidak akan aktif otomatis"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Akan aktif otomatis pada <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Akan aktif otomatis saat malam"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Tidak akan nonaktif otomatis"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Akan nonaktif otomatis pukul <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Akan nonaktif otomatis saat matahari terbit"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Cahaya Malam tidak aktif"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Lokasi perangkat diperlukan untuk menentukan waktu matahari terbenam dan terbit."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Setelan lokasi"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Aktifkan sekarang"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Nonaktifkan sekarang"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Aktifkan hingga pagi"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Nonaktifkan hingga malam"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Mode Gelap"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Jadwal"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Tidak ada"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Aktifkan dari malam hingga pagi"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Aktifkan pada waktu khusus"</string>
    <string name="dark_ui_auto_mode_custom_bedtime" msgid="8465023741946439266">"Aktifkan pada waktu tidur"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Status"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Tidak akan aktif otomatis"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Akan aktif otomatis saat malam"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Akan aktif otomatis pada <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_off_auto_mode_custom_bedtime" msgid="7759826673214624622">"Akan otomatis diaktifkan saat waktu tidur"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Tidak akan nonaktif otomatis"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Akan nonaktif otomatis saat pagi"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Akan nonaktif otomatis pukul <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_custom_bedtime" msgid="1976993025762551246">"Akan otomatis dinonaktifkan setelah waktu tidur"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"Tema gelap menggunakan latar belakang hitam agar daya baterai dapat bertahan lebih lama di beberapa layar. Jadwal tema gelap menunggu diaktifkan hingga layar nonaktif."</string>
    <string name="dark_ui_bedtime_footer_summary" msgid="5576501833145170581">"Tema gelap saat ini mengikuti jadwal Mode Waktu Tidur Anda"</string>
    <string name="dark_ui_bedtime_footer_action" msgid="1493095487994054339">"Setelan Mode Waktu Tidur"</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Waktu tunggu layar"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"Setelah tidak aktif selama <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g>"</string>
    <string name="screen_timeout_summary_not_set" msgid="5107680774964178875">"Tidak disetel"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Wallpaper"</string>
    <string name="style_and_wallpaper_settings_title" msgid="2232042809407308946">"Wallpaper &amp; gaya"</string>
    <string name="wallpaper_dashboard_summary" msgid="2324472863981057118">"Layar utama, layar kunci"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Ubah wallpaper"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Personalisasi layar Anda"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Pilih wallpaper dari"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Sesuaikan ponsel Anda"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Coba wallpaper dan gaya yang berbeda, serta banyak lagi"</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Screensaver"</string>
    <string name="keywords_screensaver" msgid="7249337959432229172">"screensaver"</string>
    <string name="screensaver_settings_when_to_dream_bedtime" msgid="3279310576803094771">"Tidak tersedia karena mode Waktu Tidur aktif"</string>
    <string name="screensaver_settings_toggle_title" msgid="6194634226897244374">"Gunakan screensaver"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Saat mengisi baterai atau terpasang di dok"</string>
    <string name="screensaver_settings_summary_dock_and_charging" msgid="8485905100159376156">"Saat dipasang ke dok &amp; mengisi daya"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Saat mengisi daya"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Saat terpasang di dok"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Tidak pernah"</string>
    <string name="screensaver_settings_summary_on" msgid="4210827304351483645">"Aktif / <xliff:g id="SCREEN_SAVER">%1$s</xliff:g>"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Mati"</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Waktu mulai"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Angkat untuk membangunkan"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Tampilan standby"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Kapan ditampilkan"</string>
    <string name="doze_title" msgid="1523090408230862316">"Aktifkan layar untuk notifikasi"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Dalam keadaan mati, layar akan menyala saat ada notifikasi baru"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Selalu tampilkan waktu dan info"</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Penggunaan baterai meningkat"</string>
    <string name="force_bold_text" msgid="4620929631102086716">"Teks tebal"</string>
    <string name="title_font_size" msgid="570613010306330622">"Ukuran font"</string>
    <string name="short_summary_font_size" msgid="8444689613442419978">"Perbesar atau perkecil teks"</string>
    <string name="sim_lock_settings" msgid="7331982427303002613">"Setelan kunci SIM"</string>
    <string name="sim_lock_settings_category" msgid="6475255139493877786">"Kunci SIM"</string>
    <string name="sim_pin_toggle" msgid="6814489621760857328">"Kunci SIM"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Ubah PIN SIM"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"PIN SIM"</string>
    <string name="sim_enable_sim_lock" msgid="6486354334679225748">"Kunci SIM"</string>
    <string name="sim_disable_sim_lock" msgid="6939439812841857306">"Buka kunci SIM"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"PIN SIM lama"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"PIN SIM baru"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Ketik ulang PIN baru"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"PIN SIM"</string>
    <string name="sim_invalid_pin_hint" msgid="3376397829969578877">"Ketik PIN berupa 4 sampai 8 angka"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"PIN tidak cocok"</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"PIN SIM berhasil diubah"</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"Tidak dapat menonaktifkan PIN."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"Tidak dapat mengaktifkan PIN."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"Oke"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Batal"</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"Gunakan <xliff:g id="CARRIER">%1$s</xliff:g> untuk data seluler?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"Anda menggunakan <xliff:g id="CARRIER2_0">%2$s</xliff:g> untuk data seluler. Jika Anda beralih ke <xliff:g id="CARRIER1">%1$s</xliff:g>, <xliff:g id="CARRIER2_1">%2$s</xliff:g> tidak akan digunakan lagi untuk data seluler."</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"Gunakan <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="8850185380445309835">"Perbarui SIM pilihan?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"<xliff:g id="NEW_SIM">%1$s</xliff:g> satu-satunya SIM di perangkat. Ingin menggunakan SIM ini untuk data seluler, panggilan telepon, dan SMS?"</string>
    <string name="enable_auto_data_switch_dialog_title" msgid="3563043560556718994">"Perbaiki sinyal data seluler?"</string>
    <string name="enable_auto_data_switch_dialog_message" msgid="5777287241521946883">"Izinkan perangkat beralih secara otomatis ke <xliff:g id="BACKUP_CARRIER">%1$s</xliff:g> untuk data seluler saat memiliki ketersediaan yang lebih baik."</string>
    <string name="auto_data_switch_dialog_managed_profile_warning" msgid="6839438290079866605">\n\n"Panggilan, pesan, dan traffic jaringan dapat dilihat oleh organisasi Anda."</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"Kode PIN SIM salah, sekarang Anda harus menghubungi operator untuk membuka kunci perangkat."</string>
    <string name="wrong_pin_code" msgid="8124222991071607958">"{count,plural, =1{Kode PIN SIM salah. Tersisa # percobaan lagi sebelum Anda harus menghubungi operator untuk membuka kunci perangkat.}other{Kode PIN SIM salah, tersisa # percobaan lagi.}}"</string>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"Kode PIN SIM salah, tinggal 1 kali mencoba lagi sebelum Anda harus menghubungi operator untuk membuka kunci perangkat."</string>
    <string name="pin_failed" msgid="3726505565797352255">"Operasi PIN SIM gagal!"</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Update sistem"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Versi Android"</string>
    <string name="security_patch" msgid="4071756145347865382">"Update keamanan Android"</string>
    <string name="model_info" msgid="8997566254717810904">"Model"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Versi hardware"</string>
    <string name="manufactured_year" msgid="3401517138700926475">"Tahun produksi"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"ID Peralatan"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Versi pita basis"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Versi kernel"</string>
    <string name="build_number" msgid="9009733242117579826">"Nomor build"</string>
    <string name="module_version" msgid="1787518340082046658">"Update sistem Google Play"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Tidak tersedia"</string>
    <string name="storage_settings" msgid="7472188817781592677">"Penyimpanan"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Penyimpanan &amp; cache"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Setelan penyimpanan"</string>
    <string name="status_eid" msgid="7532406028683438634">"EID"</string>
    <string name="eid_multi_sim" msgid="9087924808336397804">"EID (slot sim <xliff:g id="EID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim" msgid="9001570420423929507">"IMEI (slot SIM <xliff:g id="IMEI_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim_primary" msgid="7914653040843734282">"IMEI (slot SIM <xliff:g id="IMEI_SLOT_ID_PRIMARY">%1$d</xliff:g>) (utama)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Untuk melihat, pilih jaringan yang tersimpan"</string>
    <string name="status_min_number" msgid="4492899165438225714">"MIN"</string>
    <string name="status_msid_number" msgid="3871958248824595774">"MSID"</string>
    <string name="status_prl_version" msgid="9002131357502714281">"Versi PRL"</string>
    <string name="meid_multi_sim" msgid="1460689549266621286">"MEID (slot SIM <xliff:g id="MEID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="meid_multi_sim_primary" msgid="8921262417580407201">"MEID (slot SIM <xliff:g id="MEID_SLOT_ID_PRIMARY">%1$d</xliff:g>) (utama)"</string>
    <string name="scanning_status_text_on" msgid="3846571210578042940">"Aktif"</string>
    <string name="scanning_status_text_off" msgid="4002352668313705132">"Nonaktif"</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">"Jenis jaringan kuota"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Jenis jaringan suara seluler"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Info operator"</string>
    <string name="status_data_state" msgid="525196229491743487">"Status jaringan seluler"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Status layanan"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Kekuatan sinyal"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Roaming"</string>
    <string name="status_operator" msgid="4335640583552058491">"Jaringan"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"Alamat MAC Wi-Fi"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"Alamat MAC Wi-Fi perangkat"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"Alamat bluetooth"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Nomor seri"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Waktu aktif"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Menghitung..."</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Ganti nama"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Pasang"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Keluarkan"</string>
    <string name="storage_menu_format" msgid="8903698999905354146">"Format kartu SD untuk penyimpanan portabel"</string>
    <string name="storage_menu_format_button" msgid="7623565190643699626">"Format kartu"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Format sebagai portabel"</string>
    <string name="storage_menu_format_option" msgid="4886059624052908432">"Format"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Migrasikan data"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Lupakan"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Siapkan"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Kosongkan ruang"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Kelola penyimpanan"</string>
    <string name="storage_free_up_space_title" msgid="281047807372131975">"Kosongkan ruang penyimpanan"</string>
    <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Buka aplikasi Files untuk mengelola dan mengosongkan ruang penyimpanan"</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Pengguna lainnya"</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> telah dipasang"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"Tidak dapat memasang <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"<xliff:g id="NAME">%1$s</xliff:g> dikeluarkan dengan aman"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"Tidak dapat mengeluarkan <xliff:g id="NAME">%1$s</xliff:g> dengan aman"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Ganti nama penyimpanan"</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"<xliff:g id="NAME_0">^1</xliff:g> ini rusak. \n\nUntuk menggunakan <xliff:g id="NAME_1">^1</xliff:g> ini, Anda harus menyiapkannya terlebih dahulu."</string>
    <string name="storage_internal_format_details" msgid="2399034372813686846">"Anda dapat memformat kartu SD ini untuk menyimpan foto, video, musik, dan lainnya serta mengaksesnya di perangkat lain. \n\n"<b>"Semua data di kartu SD ini akan dihapus."</b>" \n\n"<b>"Sebelum memformat"</b>" \n\n"<b>"Cadangkan foto &amp; media lainnya"</b>" \nPindahkan file media Anda ke penyimpanan alternatif di perangkat ini, atau transfer ke komputer menggunakan kabel USB. \n\n"<b>"Cadangkan aplikasi"</b>" \nSemua aplikasi yang disimpan di <xliff:g id="NAME">^1</xliff:g> ini akan di-uninstal dan datanya akan dihapus. Untuk menyimpan aplikasi ini, pindahkan ke penyimpanan alternatif di perangkat ini."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><b>"Saat Anda mengeluarkan <xliff:g id="NAME_0">^1</xliff:g> ini, aplikasi yang tersimpan di situ tidak akan berfungsi lagi, dan file media yang tersimpan di situ baru dapat tersedia jika dicolokkan kembali."</b>" \n\n <xliff:g id="NAME_1">^1</xliff:g> ini diformat untuk berfungsi hanya di perangkat ini dan tidak akan berfungsi di perangkat lain."</string>
    <string name="storage_internal_forget_details" msgid="5606507270046186691">"Untuk menggunakan aplikasi, foto, atau data dalam <xliff:g id="NAME">^1</xliff:g> ini, colokkan kembali. \n\nAtau, Anda dapat memilih untuk melupakan penyimpanan ini jika perangkat tidak tersedia. \n\nJika Anda memilih untuk melupakan, semua data dalam perangkat ini akan hilang selamanya. \n\nNanti Anda dapat memasang ulang aplikasi, tetapi datanya yang disimpan di perangkat ini akan hilang."</string>
    <string name="storage_internal_forget_confirm_title" msgid="379238668153099015">"Lupakan <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"Semua aplikasi, foto, dan data yang disimpan di <xliff:g id="NAME">^1</xliff:g> ini akan hilang selamanya."</string>
    <string name="storage_detail_dialog_system" msgid="7461009051858709479">"Sistem mencakup file yang digunakan untuk menjalankan Android versi <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="storage_wizard_guest" msgid="5813419895687733649">"Pengguna mode tamu tidak dapat memformat kartu SD"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"Memformat <xliff:g id="NAME">^1</xliff:g>…"</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Jangan cabut <xliff:g id="NAME">^1</xliff:g> saat sedang diformat"</string>
    <string name="storage_wizard_ready_title" msgid="3631022511474086605">"<xliff:g id="NAME">^1</xliff:g> telah diformat"</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"Pindahkan <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"Pemindahan <xliff:g id="APP">^1</xliff:g> dan datanya ke <xliff:g id="NAME_0">^2</xliff:g> hanya akan berlangsung sebentar. Anda tidak akan dapat menggunakan aplikasi hingga pemindahan selesai. \n\nJangan cabut <xliff:g id="NAME_1">^2</xliff:g> selama pemindahan."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"Untuk memindahkan data yang dibutuhkan guna membuka <xliff:g id="APP">^1</xliff:g> pengguna."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"Memindahkan <xliff:g id="APP">^1</xliff:g>…"</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"Jangan cabut <xliff:g id="NAME">^1</xliff:g> selama pemindahan. \n\nAplikasi <xliff:g id="APP">^2</xliff:g> di perangkat ini baru dapat tersedia jika pemindahan selesai."</string>
    <string name="storage_wizard_init_v2_title" msgid="2538630338392381113">"Bagaimana Anda menggunakan <xliff:g id="NAME">^1</xliff:g> ini?"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"Atau"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="2786416384217054112">"Format kartu SD untuk penyimpanan portabel"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="2002761631147966185">"Simpan foto, video, musik, dan lainnya serta akses file dari perangkat lain. &lt;a href=https://support.google.com/android/answer/12153449&gt;Pelajari lebih lanjut cara menyiapkan kartu SD&lt;/a&gt;."</string>
    <string name="storage_wizard_init_v2_external_action" msgid="6140058734875839081">"Format"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Siapkan nanti"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"Format <xliff:g id="NAME">^1</xliff:g> ini?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"<xliff:g id="NAME_0">^1</xliff:g> perlu diformat untuk menyimpan aplikasi, file, dan media. \n\nMemformat akan menghapus konten yang ada di <xliff:g id="NAME_1">^2</xliff:g>. Agar konten tidak hilang, cadangkan ke <xliff:g id="NAME_2">^3</xliff:g> atau perangkat lain."</string>
    <string name="storage_wizard_format_confirm_v2_body_external" msgid="5810296966099830035">"<xliff:g id="NAME_0">^1</xliff:g> ini perlu diformat untuk menyimpan foto, video, musik, dan lainnya. \n\nPemformatan akan menghapus konten yang ada di <xliff:g id="NAME_1">^2</xliff:g>. Agar konten tidak hilang, cadangkan ke <xliff:g id="NAME_2">^3</xliff:g> atau perangkat lain."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"Format <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Pindahkan konten ke <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"Selama proses pemindahan:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"Jangan cabut <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Beberapa aplikasi tidak berfungsi"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Pindahkan konten"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Pindahkan konten nanti"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Memindahkan konten..."</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"<xliff:g id="NAME">^1</xliff:g> lambat"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"Anda tetap dapat menggunakan <xliff:g id="NAME_0">^1</xliff:g> ini, tetapi mungkin lambat. \n\nAplikasi yang disimpan di <xliff:g id="NAME_1">^2</xliff:g> ini mungkin tidak berfungsi dengan baik, dan transfer konten memerlukan waktu yang lama. \n\nCoba gunakan <xliff:g id="NAME_2">^3</xliff:g> yang lebih cepat, atau gunakan <xliff:g id="NAME_3">^4</xliff:g> ini untuk penyimpanan portabel."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Mulai dari awal"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Lanjutkan"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="7688457485389886923">"Anda dapat mulai menggunakan <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="3520269956641115883">"Anda dapat mulai menggunakan <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1163588718127651062">"Anda dapat mulai menggunakan <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="battery_status_title" msgid="4661768220545945771">"Status baterai"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Tingkat baterai"</string>
    <string name="communal_settings_title" msgid="2845678473945902115">"Umum"</string>
    <string name="communal_settings_summary" msgid="4923914136953940317">"Setelan umum"</string>
    <string name="apn_settings" msgid="4295467389400441299">"APN"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Edit titik akses"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"Tidak disetel"</string>
    <string name="apn_not_set_for_mvno" msgid="1141490067313964640">"Belum disetel"</string>
    <string name="apn_name" msgid="6677695784108157953">"Nama"</string>
    <string name="apn_apn" msgid="5812828833797458602">"APN"</string>
    <string name="apn_http_proxy" msgid="1052464912365838007">"Proxy"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Port"</string>
    <string name="apn_user" msgid="5831763936428279228">"Nama Pengguna"</string>
    <string name="apn_password" msgid="7435086635953953029">"Sandi"</string>
    <string name="apn_server" msgid="6997704279138388384">"Server"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"Proxy MMS"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"Port 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">"Jenis autentikasi"</string>
    <string name="apn_type" msgid="1835573305077788773">"Jenis APN"</string>
    <string name="apn_protocol" msgid="181529867160380010">"Protokol APN"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"Protokol roaming APN"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"Aktifkan/nonaktifkan APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"APN diaktifkan"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"APN dinonaktifkan"</string>
    <string name="bearer" msgid="3231443241639159358">"Operator"</string>
    <string name="mvno_type" msgid="4734654257494971247">"Jenis MVNO"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"Nilai MVNO"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Hapus APN"</string>
    <string name="menu_new" msgid="6571230342655509006">"APN baru"</string>
    <string name="menu_save" msgid="6611465355127483100">"Simpan"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Batal"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_name_empty" msgid="1258275899283079142">"Bidang Nama wajib diisi."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"APN wajib diisi."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"Bidang MCC harus terdiri dari 3 digit."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"Bidang MNC harus 2 atau 3 digit."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"Operator tidak mengizinkan penambahan APN jenis %s."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Memulihkan setelan APN default."</string>
    <string name="menu_restore" msgid="4310539620115151551">"Reset ke default"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Reset setelan APN default selesai."</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Opsi reset"</string>
    <string name="reset_mobile_network_settings_title" msgid="5616713931258506842">"Reset Setelan Jaringan Seluler"</string>
    <string name="reset_mobile_network_settings_desc" msgid="7292636387692165727">"Tindakan ini akan mereset semua setelan jaringan seluler"</string>
    <string name="reset_mobile_network_settings_confirm_title" msgid="7510965634669511241">"Reset Setelan Jaringan Seluler?"</string>
    <string name="reset_bluetooth_wifi_title" msgid="4113071322344697317">"Reset Bluetooth &amp; Wi‑Fi"</string>
    <string name="reset_bluetooth_wifi_desc" msgid="4030295669083059711">"Tindakan ini akan mereset semua setelan Wi‑Fi &amp; Bluetooth. Anda tidak dapat mengurungkan tindakan ini."</string>
    <string name="reset_bluetooth_wifi_button_text" msgid="3974098137045963639">"Reset"</string>
    <string name="reset_bluetooth_wifi_complete_toast" msgid="5893439291030574365">"Bluetooth &amp; Wi‑Fi telah direset"</string>
    <string name="erase_euicc_data_button" msgid="728078969563311737">"Hapus"</string>
    <string name="reset_esim_title" msgid="4194570573425902754">"Hapus eSIM"</string>
    <string name="reset_esim_desc" msgid="3662444090563399131">"Tindakan ini tidak akan membatalkan paket layanan seluler apa pun. Untuk mendownload SIM pengganti, hubungi operator Anda."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Reset setelan"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Reset semua setelan jaringan? Anda tidak dapat mengurungkan tindakan ini."</string>
    <string name="reset_network_final_desc_esim" msgid="1129251284212847939">"Reset semua setelan jaringan dan hapus eSIM? Anda tidak dapat mengurungkan tindakan ini."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Reset setelan"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Reset?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"Reset jaringan tidak tersedia untuk pengguna ini"</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Setelan jaringan telah direset"</string>
    <string name="reset_esim_error_title" msgid="4670073610967959597">"Tidak dapat menghapus SIM"</string>
    <string name="reset_esim_error_msg" msgid="7279607120606365250">"eSIM tidak dapat dihapus karena terjadi error.\n\nMulai ulang perangkat, lalu coba lagi."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Hapus semua data (reset ke setelan pabrik)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Hapus semua data"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"Musik"</li>\n<li>"Foto"</li>\n<li>"Data pengguna lainnya"</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"Tindakan ini tidak akan membatalkan paket layanan seluler."</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Semua informasi pribadi dan aplikasi yang didownload akan dihapus. Anda tidak dapat mengurungkan tindakan ini."</string>
    <string name="main_clear_final_desc_esim" msgid="440406836793824969">"Semua informasi pribadi, termasuk aplikasi &amp; SIM yang telah didownload, akan dihapus. Anda tidak dapat mengurungkan tindakan ini."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"Hapus semua data?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"Reset ke setelan pabrik tidak tersedia untuk pengguna ini"</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Menghapus"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Harap tunggu …"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Setelan panggilan"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Siapkan kotak pesan, penerusan panggilan, nada tunggu, ID penelepon"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"Tethering USB"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Hotspot portabel"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Tethering bluetooth"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Menambatkan"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Hotspot &amp; tethering"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Hotspot aktif, tethering"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Hotspot aktif"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Tethering"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"Tidak dapat tethering atau menggunakan hotspot portabel saat Penghemat Kuota Internet aktif"</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Hanya hotspot"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"Hanya USB"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Hanya Bluetooth"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Hanya Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Hotspot, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Hotspot, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Hotspot, Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth" msgid="1355680331767261967">"USB, Bluetooth"</string>
    <string name="tether_settings_summary_usb_and_ethernet" msgid="2195017679820919905">"USB, Ethernet"</string>
    <string name="tether_settings_summary_bluetooth_and_ethernet" msgid="1015253926959211012">"Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_bluetooth" msgid="2949043525073791732">"Hotspot, USB, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Hotspot, USB, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Hotspot, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth_and_ethernet" msgid="5880591133984166550">"USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_all" msgid="7565193614882005775">"Hotspot, USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Tidak berbagi internet dengan perangkat lain"</string>
    <string name="tether_preference_summary_off" msgid="6266799346319794630">"Nonaktif"</string>
    <string name="tethering_interface_options" msgid="7575535888135143650">"Tethering"</string>
    <string name="disable_wifi_hotspot_title" msgid="2167985468585290478">"Jangan gunakan hotspot Wi-Fi"</string>
    <string name="disable_wifi_hotspot_when_usb_on" msgid="220439059794714583">"Bagikan internet hanya melalui USB"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_on" msgid="4711723299880116345">"Bagikan internet hanya melalui Bluetooth"</string>
    <string name="disable_wifi_hotspot_when_ethernet_on" msgid="4123242400542103599">"Bagikan internet hanya melalui Ethernet"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_on" msgid="5258774769658150180">"Bagikan internet hanya melalui USB dan Bluetooth"</string>
    <string name="disable_wifi_hotspot_when_usb_and_ethernet_on" msgid="7126313562907225612">"Bagikan internet hanya melalui USB dan Ethernet"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_and_ethernet_on" msgid="2943464651349235967">"Bagikan internet hanya melalui Bluetooth dan Ethernet"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_and_ethernet_on" msgid="3934609816834760008">"Bagikan internet hanya melalui USB, Bluetooth, dan Ethernet"</string>
    <string name="usb_title" msgid="1157283449840612901">"USB"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"Tethering USB"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Tethering bluetooth"</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Tethering Ethernet"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Gunakan hotspot dan tethering untuk menyediakan koneksi internet bagi perangkat lain melalui koneksi kuota seluler Anda. Aplikasi juga dapat membuat hotspot untuk berbagi konten dengan perangkat sekitar."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Gunakan hotspot dan tethering untuk menyediakan koneksi internet bagi perangkat lain melalui koneksi Wi‑Fi atau data seluler Anda. Aplikasi juga dapat membuat hotspot untuk berbagi konten dengan perangkat sekitar."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Bantuan"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Jaringan seluler"</string>
    <string name="manage_mobile_plan_title" msgid="5616930513733409064">"Paket seluler"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"Aplikasi SMS"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Ubah aplikasi SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"Gunakan <xliff:g id="NEW_APP">%1$s</xliff:g> dan bukan <xliff:g id="CURRENT_APP">%2$s</xliff:g> sebagai aplikasi SMS?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="6215622785087181275">"Gunakan <xliff:g id="NEW_APP">%s</xliff:g> sebagai aplikasi SMS?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"Ubah Wi-Fi Assistant?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"Gunakan <xliff:g id="NEW_APP">%1$s</xliff:g> sebagai ganti <xliff:g id="CURRENT_APP">%2$s</xliff:g> untuk mengelola koneksi jaringan?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Gunakan <xliff:g id="NEW_APP">%s</xliff:g> untuk mengelola koneksi jaringan?"</string>
    <string name="mobile_unknown_sim_operator" msgid="6650422533065760963">"Operator SIM tidak dikenal"</string>
    <string name="mobile_no_provisioning_url" msgid="609462719893503773">"<xliff:g id="OPERATOR">%1$s</xliff:g> tidak punya situs web penyediaanyang dikenal"</string>
    <string name="mobile_insert_sim_card" msgid="3639245241283948038">"Masukkan kartu SIM dan mulai ulang"</string>
    <string name="mobile_connect_to_internet" msgid="8162654404357069060">"Sambungkan ke internet"</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Permintaan lokasi terbaru"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Lokasi untuk profil kerja"</string>
    <string name="location_app_level_permissions" msgid="907206607664629759">"Izin akses lokasi aplikasi"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Lokasi nonaktif"</string>
    <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# dari {total} aplikasi memiliki akses ke lokasi}other{# dari {total} aplikasi memiliki akses ke lokasi}}"</string>
    <string name="location_category_recent_location_access" msgid="2558063524482178146">"Akses terbaru"</string>
    <string name="location_recent_location_access_see_all" msgid="4203102419355323325">"Lihat semua"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Lihat detail"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"Tidak ada aplikasi yang meminta lokasi baru-baru ini"</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Tidak ada aplikasi yang baru-baru ini mengakses lokasi"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Penggunaan baterai tinggi"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Penggunaan baterai rendah"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"Pemindaian Wi-Fi"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Izinkan aplikasi dan layanan untuk memindai jaringan Wi-Fi kapan saja, bahkan saat Wi-Fi nonaktif. Ini dapat dilakukan, misalnya, untuk meningkatkan kualitas fitur dan layanan berbasis lokasi."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Pemindaian Bluetooth"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Izinkan aplikasi dan layanan untuk memindai perangkat di sekitar kapan saja, bahkan saat Bluetooth nonaktif. Ini dapat dilakukan, misalnya, untuk meningkatkan kualitas fitur dan layanan berbasis lokasi."</string>
    <string name="location_services_preference_title" msgid="604317859531782159">"Layanan lokasi"</string>
    <string name="location_services_screen_title" msgid="5640002489976602476">"Layanan lokasi"</string>
    <string name="location_time_zone_detection_toggle_title" msgid="6478751613645015287">"Gunakan lokasi"</string>
    <string name="location_time_zone_detection_status_title" msgid="8903495354385600423">"Tidak dapat otomatis menyetel zona waktu"</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">"Lokasi atau Layanan Lokasi nonaktif"</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">"Perlu lokasi perangkat"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_message" msgid="5846316326139169523">"Untuk menyetel zona waktu menggunakan lokasi Anda, aktifkan lokasi, lalu perbarui setelan zona waktu"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_ok_button" msgid="2685647335717750297">"Setelan lokasi"</string>
    <string name="location_time_zone_provider_fix_dialog_ok_button" msgid="9026666001835079126">"Perbaiki ini"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_cancel_button" msgid="3968729678789071154">"Batal"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="6264253990141650280">"Zona waktu otomatis nonaktif"</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"Deteksi zona waktu lokasi dinonaktifkan"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"Deteksi zona waktu lokasi tidak didukung"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Perubahan deteksi zona waktu lokasi tidak diizinkan"</string>
    <string name="location_time_zone_detection_auto_is_on" msgid="8797434659844659323">"Lokasi dapat digunakan untuk menyetel zona waktu"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Lihat info legal, status, versi software"</string>
    <string name="legal_information" msgid="7509900979811934843">"Informasi hukum"</string>
    <string name="manual" msgid="3651593989906084868">"Manual"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Label peraturan"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Manual keselamatan &amp; peraturan"</string>
    <string name="copyright_title" msgid="83245306827757857">"Hak cipta"</string>
    <string name="license_title" msgid="8745742085916617540">"Lisensi"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Lisensi update sistem Google Play"</string>
    <string name="terms_title" msgid="2071742973672326073">"Persyaratan dan ketentuan"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"Lisensi WebView Sistem"</string>
    <string name="wallpaper_attributions" msgid="4323659759250650736">"Kredit wallpaper"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Penyedia citra satelit:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Manual"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Ada masalah saat memuat manual."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Lisensi pihak ketiga"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Ada masalah saat memuat lisensi."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Memuat…"</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Memuat…"</string>
    <string name="lockpassword_choose_your_password_header" msgid="2407205113298094824">"Setel sandi"</string>
    <string name="lockpassword_choose_your_profile_password_header" msgid="7038997227611893312">"Setel sandi profil kerja"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7754265746504679473">"Setel PIN"</string>
    <string name="lockpassword_choose_your_profile_pin_header" msgid="4581749963670819048">"Setel PIN profil kerja"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="5674909390779586252">"Setel pola"</string>
    <string name="lockpassword_choose_your_pattern_description" msgid="6808109256008481046">"Untuk keamanan tambahan, setel pola untuk membuka kunci perangkat"</string>
    <string name="lockpassword_choose_your_profile_pattern_header" msgid="3101811498330756641">"Setel pola profil kerja"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Untuk memakai sidik jari, setel sandi"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Untuk memakai sidik jari, setel pola"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Untuk keamanan, setel PIN"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Untuk memakai sidik jari, setel PIN"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Masukkan ulang sandi"</string>
    <string name="lockpassword_reenter_your_profile_password_header" msgid="3812040127714827685">"Masukkan kembali sandi profil kerja"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Masukkan sandi profil kerja"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Konfirmasi pola"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Masukkan pola profil kerja"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Masukkan ulang PIN"</string>
    <string name="lockpassword_reenter_your_profile_pin_header" msgid="2890233614560435538">"Masukkan kembali PIN profil kerja"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Masukkan PIN profil kerja"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Sandi tidak cocok"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"PIN tidak cocok"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Ulangi gambar pola"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Buka pilihan"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Sandi telah ditetapkan"</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"PIN telah ditetapkan"</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Pola telah ditetapkan"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="622276003801157839">"Untuk memakai Buka dengan Wajah, setel sandi"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="7333603579958317102">"Untuk memakai Buka dengan Wajah, setel pola"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="704061826984851309">"Untuk memakai Buka dengan Wajah, setel PIN"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="2053366309272487015">"Setel sandi untuk menggunakan wajah atau sidik jari"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4038476475293734905">"Setel pola untuk menggunakan wajah atau sidik jari"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="9086039918921009380">"Setel PIN untuk menggunakan wajah atau sidik jari"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Lupa sandi?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Lupa pola?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"Lupa PIN?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7692794426682501482">"Gunakan pola perangkat untuk melanjutkan"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="9206928587904701094">"Masukkan PIN perangkat untuk melanjutkan"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="2616127423884477152">"Masukkan sandi perangkat untuk melanjutkan"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="9110305410672321714">"Gunakan pola profil kerja untuk melanjutkan"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Masukkan PIN profil kerja untuk melanjutkan"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Masukkan sandi profil kerja untuk melanjutkan"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Untuk keamanan tambahan, gunakan pola perangkat"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Untuk keamanan tambahan, masukkan PIN perangkat"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Untuk keamanan tambahan, masukkan sandi perangkat"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Untuk keamanan tambahan, gunakan pola profil kerja"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Untuk keamanan tambahan, masukkan PIN profil kerja"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Untuk keamanan tambahan, masukkan sandi profil kerja"</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Verifikasi pola"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"Verifikasi PIN"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Verifikasi sandi"</string>
    <string name="lockpassword_remote_validation_header" msgid="4992647285784962073">"Verifikasi diri Anda"</string>
    <string name="lockpassword_remote_validation_pattern_details" msgid="4655537780358707983">"Untuk mentransfer Akun Google, setelan, dan lainnya, masukkan pola perangkat Anda yang lainnya. Pola Anda dienkripsi."</string>
    <string name="lockpassword_remote_validation_pin_details" msgid="2373654227583206297">"Untuk mentransfer Akun Google, setelan, dan lainnya, masukkan PIN perangkat Anda yang lainnya. PIN Anda dienkripsi."</string>
    <string name="lockpassword_remote_validation_password_details" msgid="3482328925925888340">"Untuk mentransfer Akun Google, setelan, dan lainnya, masukkan sandi perangkat Anda yang lainnya. Sandi Anda dienkripsi."</string>
    <string name="lockpassword_remote_validation_set_pattern_as_screenlock" msgid="7595104317648465901">"Juga gunakan pola untuk membuka kunci perangkat ini"</string>
    <string name="lockpassword_remote_validation_set_pin_as_screenlock" msgid="509672303005547218">"Juga gunakan PIN untuk membuka kunci perangkat ini"</string>
    <string name="lockpassword_remote_validation_set_password_as_screenlock" msgid="2066701840753591922">"Juga gunakan sandi untuk membuka kunci perangkat ini"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"PIN Salah"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Sandi salah"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Pola salah"</string>
    <string name="work_challenge_emergency_button_text" msgid="5529942788380505927">"Darurat"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Keamanan perangkat"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Ubah pola pembuka kunci"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Ubah PIN pembuka kunci"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Gambar pola pembuka kunci"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Tekan Menu untuk bantuan."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Angkat jari ketika selesai"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Sambungkan setidaknya <xliff:g id="NUMBER">%d</xliff:g> titik. Coba lagi."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Pola direkam"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Gambar lagi pola untuk mengonfirmasi"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Pola pembuka kunci baru Anda"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Konfirmasi"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Gambar ulang"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Hapus"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Lanjutkan"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Pola pembuka kunci"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Memerlukan pola"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Harus membuat pola untuk membuka layar"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Perlihatkan pola"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_title" msgid="7172693275721931683">"Privasi PIN yang ditingkatkan"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_summary" msgid="8639588868341114740">"Nonaktifkan animasi saat memasukkan PIN"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Perlihatkan pola profil"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Bergetar saat diketuk"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Tombol daya langsung mengunci"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"Kecuali jika tetap tidak dikunci oleh <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="2193588309557281466">"Setel pola pembuka kunci"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Ubah pola pembuka kunci"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Cara menggambar pola pembuka kunci"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Terlalu banyak kesalahan pola. Coba kembali dalam <xliff:g id="NUMBER">%d</xliff:g> detik."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"Aplikasi tidak dipasang pada ponsel Anda."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Keamanan profil kerja"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Kunci layar profil kerja"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Gunakan satu kunci"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Gunakan satu kunci untuk profil kerja dan layar perangkat"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"Gunakan satu kunci?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"Perangkat akan menggunakan layar kunci profil kerja Anda. Kebijakan kerja akan berlaku untuk kedua kunci."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"Kunci profil kerja tidak memenuhi persyaratan keamanan organisasi. Anda dapat menggunakan kunci yang sama untuk layar perangkat dan profil kerja, namun kebijakan kunci profil kerja apa pun akan berlaku."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Gunakan satu kunci"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Gunakan satu kunci"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Sama dengan kunci layar perangkat"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Kelola aplikasi"</string>
    <string name="applications_settings" msgid="1941993743933425622">"Info aplikasi"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"Setelan apl"</string>
    <string name="install_applications" msgid="3921609656584369901">"Sumber tidak dikenal"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Izinkan semua sumber aplikasi"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Aplikasi yang baru dibuka"</string>
    <string name="see_all_apps_title" msgid="1650653853942381797">"{count,plural, =1{Lihat semua aplikasi}other{Lihat semua # aplikasi}}"</string>
    <string name="forgot_password_title" msgid="3967873480875239885">"Hubungi admin IT"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"Mereka dapat membantu Anda menyetel ulang PIN, pola, atau sandi"</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Setelan lanjutan"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Aktifkan opsi setelan yang lain"</string>
    <string name="application_info_label" msgid="1015706497694165866">"Info aplikasi"</string>
    <string name="storage_label" msgid="2522307545547515733">"Penyimpanan"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Buka secara default"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Default"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Kompatibilitas layar"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Izin"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Cache"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Hapus cache"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Cache"</string>
    <string name="uri_permissions_text" msgid="8406345863117405105">"{count,plural, =1{1 item}other{# item}}"</string>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Hapus akses"</string>
    <string name="controls_label" msgid="8671492254263626383">"Kontrol"</string>
    <string name="force_stop" msgid="2681771622136916280">"Paksa berhenti"</string>
    <string name="total_size_label" msgid="2052185048749658866">"Total"</string>
    <string name="application_size_label" msgid="6407051020651716729">"Ukuran aplikasi"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"Apl penyimpanan USB"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Data pengguna"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Uninstal"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Uninstal untuk semua pengguna"</string>
    <string name="install_text" msgid="4558333621516996473">"Instal"</string>
    <string name="disable_text" msgid="5146002260857428005">"Nonaktifkan"</string>
    <string name="enable_text" msgid="8570798764647110430">"Aktifkan"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Hapus penyimpanan"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Uninstal pembaruan"</string>
    <string name="app_restricted_settings_lockscreen_title" msgid="5993061278264872648">"Izinkan setelan terbatas"</string>
    <string name="auto_launch_enable_text" msgid="8912714475823807798">"Beberapa aktivitas yang Anda pilih terbuka di aplikasi ini secara default."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Anda telah memilih untuk mengizinkan aplikasi ini untuk membuat widget dan mengakses data mereka."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"Tidak ada setelan default."</string>
    <string name="clear_activities" msgid="488089228657585700">"Hapus preferensi default"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"Apl ini mungkin tidak didesain untuk layar Anda. Anda dapat mengontrol cara menyesuaikannya dengan layar di sini."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Tanyakan saat diluncurkan"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Sesuaikan skala apl"</string>
    <string name="unknown" msgid="8192160131923461175">"Tidak diketahui"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Urutkan menurut nama"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Urutkan menurut ukuran"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Terbaru"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Paling sering"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Lihat layanan berjalan"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Lihat proses di cache"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Aplikasi darurat"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Reset preferensi aplikasi"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"Reset preferensi aplikasi?"</string>
    <string name="reset_app_preferences_desc" msgid="8550782670650158299">"Tindakan ini akan mereset semua preferensi untuk:\n\n"<li>"Aplikasi yang dinonaktifkan"</li>\n<li>"Notifikasi aplikasi yang dinonaktifkan"</li>\n<li>"Aplikasi default untuk tindakan"</li>\n<li>"Batasan data latar belakang untuk aplikasi"</li>\n<li>"Batasan izin apa pun"</li>\n<li>"Setelan penggunaan baterai"</li>\n\n"Data aplikasi tidak akan hilang."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Reset aplikasi"</string>
    <string name="filter" msgid="9039576690686251462">"Filter"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Pilih opsi filter"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Semua aplikasi"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Aplikasi yang dinonaktifkan"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Terdownload"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Menjalankan"</string>
    <string name="not_installed" msgid="5074606858798519449">"Tidak dipasang untuk pengguna ini"</string>
    <string name="installed" msgid="2837449358488825884">"Terinstal"</string>
    <string name="no_applications" msgid="985069304755391640">"Tidak ada aplikasi."</string>
    <string name="internal_storage" msgid="999496851424448809">"Penyimpanan internal"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Menghitung ulang ukuran..."</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Hapus data aplikasi?"</string>
    <string name="clear_data_dlg_text" msgid="3440011276559762619">"Data aplikasi ini, termasuk file dan setelan, akan dihapus secara permanen dari perangkat ini"</string>
    <string name="dlg_ok" msgid="1421350367857960997">"Oke"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Batal"</string>
    <string name="dlg_delete" msgid="1790919205039397659">"Hapus"</string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"Apl tersebut tidak ditemukan di dalam daftar apl yang terpasang."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Tidak dapat menghapus penyimpanan untuk aplikasi."</string>
    <string name="computing_size" msgid="4915310659841174866">"Menghitung..."</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Tidak dapat menghitung ukuran paket."</string>
    <string name="version_text" msgid="7628938665256107608">"versi <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Pindahkan"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"Migrasi lain sedang berlangsung."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"Ruang penyimpanan tidak cukup."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"Apl tidak ada."</string>
    <string name="invalid_location" msgid="8013853455355520557">"Lokasi pemasangan tidak valid."</string>
    <string name="system_package" msgid="7559476279008519360">"Pembaruan sistem tidak dapat dipasang pada media eksternal."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Aplikasi admin perangkat tidak dapat diinstal di media eksternal"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Paksa berhenti?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Jika aplikasi dihentikan paksa, fungsinya mungkin akan terganggu."</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Menonaktifkan aplikasi"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"Jika Anda menonaktifkan aplikasi ini, Android dan aplikasi lain mungkin tidak berfungsi lagi sesuai harapan. Perlu diingat, Anda tidak dapat menghapus aplikasi yang disertakan oleh pabrikan di perangkat Anda. Namun, Anda dapat menonaktifkannya, yang berarti mematikan dan menyembunyikan aplikasi tersebut di perangkat Anda."</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"App Store"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Detail aplikasi"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"Aplikasi diinstal dari <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Info selengkapnya di <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"Berjalan"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Tidak pernah digunakan)"</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Penggunaan penyimpanan"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Memulai ulang"</string>
    <string name="cached" msgid="5379485147573438201">"Proses latar belakang dalam cache"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Tidak ada yang berjalan."</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Dimulai oleh apl."</string>
    <!-- no translation found for service_client_name (2210898622981598861) -->
    <skip />
    <string name="service_background_processes" msgid="2800539421534521948">"<xliff:g id="MEMORY">%1$s</xliff:g> kosong"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"<xliff:g id="MEMORY">%1$s</xliff:g> digunakan"</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">"Pengguna: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Pengguna yang dihapus"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proses dan <xliff:g id="NUMSERVICES">%2$d</xliff:g>layanan"</string>
    <string name="running_processes_item_description_s_p" msgid="1209371773353932361">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proses dan <xliff:g id="NUMSERVICES">%2$d</xliff:g> layanan"</string>
    <string name="running_processes_item_description_p_s" msgid="8957061449107822282">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proses dan <xliff:g id="NUMSERVICES">%2$d</xliff:g> layanan"</string>
    <string name="running_processes_item_description_p_p" msgid="3292999232897469679">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proses dan <xliff:g id="NUMSERVICES">%2$d</xliff:g> layanan"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Memori perangkat"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"Penggunaan RAM aplikasi"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"Sistem"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Aplikasi"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Kosong"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Terpakai"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"Dalam Cache"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> RAM"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Aplikasi yang berjalan"</string>
    <string name="no_services" msgid="3898812785511572899">"Tidak aktif"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Layanan"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Proses"</string>
    <string name="service_stop" msgid="5712522600201308795">"Hentikan"</string>
    <string name="service_manage" msgid="3896322986828332075">"Setelan"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"Layanan ini dimulai oleh aplikasinya. Menghentikan layanan dapat mengakibatkan gagalnya apl."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"Apl ini tidak dapat dihentikan dengan aman. Jika Anda menghentikannya, beberapa pekerjaan yang sedang dilakukan mungkin akan hilang."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"Ini adalah proses apl lama yang masih berjalan seandainya dibutuhkan lagi. Biasanya tidak ada alasan untuk menghentikannya."</string>
    <string name="service_manage_description" msgid="6615788996428486121">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: sedang digunakan. Ketuk Setelan untuk mengontrolnya."</string>
    <string name="main_running_process_description" msgid="6685973937935027773">"Proses utama sedang digunakan."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"Layanan <xliff:g id="COMP_NAME">%1$s</xliff:g> sedang digunakan."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"Penyedia <xliff:g id="COMP_NAME">%1$s</xliff:g> sedang digunakan."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Hentikan layanan sistem?"</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Bahasa, masukan &amp; gestur"</string>
    <string name="language_settings" msgid="8700174277543875046">"Bahasa &amp; input"</string>
    <string name="languages_settings" msgid="5784775502251770671">"Bahasa"</string>
    <string name="keyboard_settings" msgid="184185708597386454">"Keyboard"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Anda tidak memiliki izin untuk mengubah bahasa perangkat."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Bahasa &amp; masukan"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Alat"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Keyboard &amp; metode masukan"</string>
    <string name="system_language" msgid="1146762166579643257">"Bahasa Sistem"</string>
    <string name="phone_language" msgid="5986939176239963826">"Bahasa"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Penggantian otomatis"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Perbaiki kata yang salah eja"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Huruf besar otomatis"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Besarkan huruf pertama pada kalimat"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Beri tanda baca otomatis"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Setelan keyboard fisik"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Tekan Spasi dua kali untuk memasukkan \".\""</string>
    <string name="show_password" msgid="7101900779571040117">"Tampilkan sandi"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Tampilkan karakter sejenak saat Anda mengetik"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"Pemeriksa ejaan ini mungkin dapat mengumpulkan semua teks yang Anda ketik, termasuk data pribadi seperti sandi dan nomor kartu kredit. Pemeriksa ejaan ini berasal dari aplikasi <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Gunakan pemeriksa ejaan ini?"</string>
    <string name="spellchecker_quick_settings" msgid="6449414356743946577">"Setelan"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Bahasa"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Keyboard"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Keyboard virtual"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Keyboard virtual yang Tersedia"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Kelola keyboard virtual"</string>
    <string name="keyboard_options_category" msgid="8040137073401152608">"Opsi"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Keyboard fisik"</string>
    <string name="show_ime" msgid="4334255501724746849">"Gunakan keyboard virtual"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Biarkan di layar meski keyboard fisik aktif"</string>
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Pintasan keyboard"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Tampilkan daftar pintasan"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Keyboard &amp; fitur profil kerja"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Keyboard virtual untuk kerja"</string>
    <string name="keyboard_default_layout" msgid="5377811770620422301">"Default"</string>
    <string name="trackpad_settings" msgid="2071131324087677005">"Touchpad"</string>
    <string name="trackpad_mouse_settings" msgid="136226693583218429">"Touchpad &amp; mouse"</string>
    <string name="trackpad_settings_summary" msgid="3369855644136760402">"Kecepatan kursor, gestur"</string>
    <string name="trackpad_tap_to_click" msgid="1938230946542070746">"Ketuk untuk mengklik"</string>
    <string name="trackpad_touchpad_gesture_title" msgid="7568052847609914436">"Gestur touchpad"</string>
    <string name="trackpad_touchpad_gesture_summary" msgid="6256074591395359124">"Sesuaikan setiap gestur navigasi touchpad"</string>
    <string name="trackpad_reverse_scrolling_title" msgid="422877284529360866">"Scroll terbalik"</string>
    <string name="trackpad_reverse_scrolling_summary" msgid="6048648562887499036">"Konten akan bergerak ke atas saat Anda men-scroll ke bawah"</string>
    <string name="trackpad_bottom_right_tap_title" msgid="6275428879042702880">"Ketuk kanan bawah"</string>
    <string name="trackpad_bottom_right_tap_summary" msgid="8734094086900680674">"Ketuk pojok kanan bawah touchpad untuk melihat opsi lainnya"</string>
    <string name="trackpad_pointer_speed" msgid="7786579408631352625">"Kecepatan kursor"</string>
    <string name="trackpad_touch_gesture" msgid="8641725062131922497">"Pelajari gestur touchpad"</string>
    <string name="gesture_title_go_home" msgid="3682238648647225933">"Membuka layar utama"</string>
    <string name="gesture_summary_go_home" msgid="6409031586904205741">"Geser ke atas dengan tiga jari di touchpad"</string>
    <string name="gesture_title_go_back" msgid="6619462058488419802">"Kembali"</string>
    <string name="gesture_summary_go_back" msgid="4981604277892236888">"Geser dari kiri atau kanan dengan tiga jari"</string>
    <string name="gesture_title_recent_apps" msgid="6082688963233208761">"Melihat aplikasi terbaru"</string>
    <string name="gesture_summary_recent_apps" msgid="6643179135202417509">"Geser ke atas dengan tiga jari, tahan, lalu lepaskan"</string>
    <string name="gesture_title_notifications" msgid="791717222472350194">"Melihat notifikasi &amp; Setelan Cepat"</string>
    <string name="gesture_summary_notifications" msgid="8419514601638387255">"Geser ke bawah dengan tiga jari di layar utama"</string>
    <string name="gesture_title_switch_apps" msgid="5840994412037872157">"Beralih aplikasi"</string>
    <string name="gesture_summary_switch_apps" msgid="6842648062151413042">"Geser ke kiri atau kanan dengan empat jari"</string>
    <string name="gesture_button_skip" msgid="5174842083451193213">"Lewati"</string>
    <string name="gesture_button_next" msgid="695288092704187356">"Berikutnya"</string>
    <string name="gesture_button_restart" msgid="1895850891992530133">"Mulai ulang"</string>
    <string name="gesture_button_done" msgid="6387900351203032188">"Selesai"</string>
    <string name="trackpad_go_back_title" msgid="5312164160947491440">"Kembali"</string>
    <string name="trackpad_go_back_summary" msgid="4201901101085902768">"Geser ke kiri atau kanan dengan tiga jari"</string>
    <string name="trackpad_go_home_title" msgid="2146525662148291552">"Buka layar utama"</string>
    <string name="trackpad_go_home_summary" msgid="2222744701528360887">"Geser ke atas dengan tiga jari"</string>
    <string name="trackpad_recent_apps_title" msgid="8195970908411585445">"Aplikasi terbaru"</string>
    <string name="trackpad_recent_apps_summary" msgid="2685092851677573794">"Geser ke atas dengan tiga jari, lalu tahan"</string>
    <string name="trackpad_notifications_title" msgid="3521663305043747880">"Notifikasi"</string>
    <string name="trackpad_notifications_summary" msgid="7663647367648690040">"Geser ke bawah dengan tiga jari"</string>
    <string name="trackpad_switch_apps_title" msgid="7342032935377284039">"Beralih aplikasi"</string>
    <string name="trackpad_switch_apps_summary" msgid="9193942041912927440">"Geser ke kiri atau kanan dengan empat jari"</string>
    <string name="modifier_keys_settings" msgid="2537108435032034683">"Tombol pengubah"</string>
    <string name="modifier_keys_settings_summary" msgid="6933143361657444436">"Ubah perilaku tombol"</string>
    <string name="modifier_keys_reset_title" msgid="948294258402761066">"Reset semua"</string>
    <string name="modifier_keys_default_summary" msgid="8701640508670973258">"Default"</string>
    <string name="modifier_keys_reset_message" msgid="5236994817619936058">"Yakin ingin mereset semua tombol pengubah ke defaultnya?"</string>
    <string name="modifier_keys_done" msgid="8196199314913909700">"Selesai"</string>
    <string name="modifier_keys_cancel" msgid="7136520252570826772">"Batalkan"</string>
    <string name="modifier_keys_reset" msgid="551170906710422041">"Reset"</string>
    <string name="modifier_keys_picker_title" msgid="244545904150587851">"Pilih tombol pengubah"</string>
    <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Pilih tombol baru untuk <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"Default"</string>
    <string name="speech_category_title" msgid="5995161659186229742">"Ucapan"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Kecepatan kursor"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Pengendali Game"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Mengalihkan getaran"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Kirim getaran ke pengontrol game saat terhubung"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Pilih tata letak keyboard"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Siapkan tata letak keyboard"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Untuk beralih, tekan Control-Spasi"</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Default"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Tata letak keyboard"</string>
    <string name="keyboard_layout_picker_category_title" msgid="2369473692906329772">"Tata letak keyboard fisik"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Kamus pribadi"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Kamus pribadi untuk kerja"</string>
    <string name="user_dict_settings_summary" msgid="4939694372338975081">"Tambahkan kata-kata untuk digunakan dalam aplikasi seperti pemeriksa ejaan"</string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Tambahkan"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Tambahkan ke kamus"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Frasa"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Opsi lainnya"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Sedikit opsi"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"Oke"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Kata:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Pintasan:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Bahasa:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Ketik kata"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Pintasan opsional"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Edit kata"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Edit"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Hapus"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"Tidak ada kata-kata dalam kamus pengguna. Untuk menambahkan kata, ketuk Tambahkan (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"Untuk semua bahasa"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Bahasa lainnya..."</string>
    <string name="testing" msgid="6294172343766732037">"Menguji"</string>
    <string name="keyboard_settings_summary" msgid="9188442758316476986">"Keyboard virtual, alat"</string>
    <string name="keyboard_settings_with_physical_keyboard_summary" msgid="2240779804018260938">"Keyboard virtual, keyboard fisik, alat"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Keyboard fisik"</string>
    <string name="enabled_locales_keyboard_layout" msgid="3939886151098958639">"Tata letak"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Pilih gadget"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Pilih widget"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Buat widget dan izinkan akses?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5825298768068148804">"Setelah Anda membuat widget, aplikasi akan dapat mengakses semua yang ditampilkan.\n\nAplikasi: <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g>\nWidget: <xliff:g id="WIDGET_LABEL">%2$s</xliff:g>\n"</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7268758525344468364">"Selalu izinkan <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> untuk membuat widget dan mengakses data mereka"</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Statistik penggunaan"</string>
    <string name="usage_stats_sort_by_usage_time" msgid="2927310334119998301">"Urutkan menurut waktu penggunaan"</string>
    <string name="usage_stats_sort_by_last_time_used" msgid="7039213339779884017">"Urutkan menurut terakhir digunakan"</string>
    <string name="usage_stats_sort_by_app_name" msgid="4463833145514850478">"Urutkan menurut nama aplikasi"</string>
    <string name="last_time_used_label" msgid="2639712813493534074">"Terakhir kali digunakan"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Waktu penggunaan"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Aksesibilitas"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Setelan aksesibilitas"</string>
    <string name="accessibility_settings_summary" msgid="2366627644570558503">"Tampilan, interaksi, audio"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Setelan Pandangan"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"Anda dapat menyesuaikan perangkat ini sesuai kebutuhan. Fitur aksesibilitas ini dapat diubah nanti di Setelan."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Ubah ukuran font"</string>
    <string name="screen_reader_category_title" msgid="5825700839731107803">"Pembaca layar"</string>
    <string name="captions_category_title" msgid="574490148949400274">"Teks"</string>
    <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
    <string name="general_category_title" msgid="6298579528716834157">"Umum"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Tampilan"</string>
    <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Warna dan gerakan"</string>
    <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Buat layar lebih gelap"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Kontrol interaksi"</string>
    <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Kontrol waktu"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Kontrol sistem"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Aplikasi yang didownload"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Eksperimental"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Tanda fitur"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_title" msgid="401330708633716596">"Pemfilteran log snoop HCI Bluetooth"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_summary" msgid="1319792184194176235">"Setel filter"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_footer" msgid="4158945851818483666">"Nonaktifkan dan aktifkan Bluetooth untuk menerapkan perubahan"</string>
    <string name="bt_hci_snoop_log_filter_pbap_title" msgid="1735427364451634823">"PBAP pemfilteran log snoop HCI Bluetooth"</string>
    <string name="bt_hci_snoop_log_filter_map_title" msgid="180092480793945544">"MAP pemfilteran log snoop HCI Bluetooth"</string>
    <string name="bt_hci_snoop_log_filter_summary" msgid="7217091930762522599">"Setel mode pemfilteran. (Nonaktifkan dan aktifkan Bluetooth untuk menerapkan perubahan)"</string>
    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary" msgid="8824952559433361848">"Setel mode log snoop HCI Bluetooth ke Diaktifkan Difilter untuk mengubah opsi ini"</string>
    <string name="talkback_title" msgid="8756080454514251327">"TalkBack"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Pembaca layar khusus untuk orang yang mengalami kebutaan atau gangguan penglihatan"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Ketuk item di layar untuk mendengar item tersebut dibacakan"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Preferensi teks"</string>
    <string name="accessibility_captioning_about_title" msgid="3542171637334191563">"Tentang preferensi teks"</string>
    <string name="accessibility_captioning_footer_learn_more_content_description" msgid="5730040700677017706">"Pelajari preferensi teks lebih lanjut"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Pembesaran"</string>
    <string name="accessibility_screen_magnification_shortcut_title" msgid="2387963646377987780">"Pintasan pembesaran"</string>
    <string name="accessibility_screen_magnification_follow_typing_title" msgid="6379517513916651560">"Perbesar saat mengetik"</string>
    <string name="accessibility_screen_magnification_follow_typing_summary" msgid="2882250257391761678">"Kaca pembesar mengikuti teks saat Anda mengetik"</string>
    <string name="accessibility_screen_magnification_always_on_title" msgid="3814297443759580936">"Tetap aktif saat beralih aplikasi"</string>
    <string name="accessibility_screen_magnification_always_on_summary" msgid="306908451430863049">"Kaca pembesar tetap aktif dan memperkecil tampilan saat Anda beralih aplikasi"</string>
    <string name="accessibility_screen_magnification_joystick_title" msgid="1803769708582404964">"Joystick"</string>
    <string name="accessibility_screen_magnification_joystick_summary" msgid="4640300148573982720">"Aktifkan dan gerakkan kaca pembesar dengan joystick di layar. Sentuh lama, lalu tarik joystick untuk mengontrol kaca pembesar. Ketuk dan tarik untuk menggerakkan joystick."</string>
    <string name="accessibility_screen_magnification_about_title" msgid="8857919020223505415">"Tentang pembesaran"</string>
    <string name="accessibility_screen_magnification_footer_learn_more_content_description" msgid="924848332575978463">"Pelajari lebih lanjut pembesaran"</string>
    <string name="accessibility_magnification_mode_title" msgid="8446475127807168063">"Jenis pembesaran"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="8498648925928109462">"Memperbesar layar penuh, area tertentu, atau beralih antara kedua opsi tersebut"</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Layar penuh"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="9191632962955877019">"Layar sebagian"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="8107511976748799455">"Beralih antara layar penuh dan sebagian"</string>
    <string name="accessibility_magnification_mode_dialog_title" msgid="9151027667059878578">"Pilih cara pembesaran"</string>
    <string name="accessibility_magnification_mode_dialog_option_full_screen" msgid="4892487869954032029">"Perbesar layar penuh"</string>
    <string name="accessibility_magnification_mode_dialog_option_window" msgid="4492443201099153362">"Perbesar sebagian layar"</string>
    <string name="accessibility_magnification_mode_dialog_option_switch" msgid="561043521011229424">"Beralih antara layar penuh dan sebagian"</string>
    <string name="accessibility_magnification_area_settings_mode_switch_summary" msgid="2885238806099080966">"Ketuk tombol beralih untuk beralih di antara kedua opsi"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Beralih ke tombol Aksesibilitas?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="7718653917415163833">"Menggunakan ketuk tiga kali untuk memperbesar bagian layar Anda akan menyebabkan penundaan pengetikan dan penundaan lainnya.\n\nTombol aksesibilitas mengambang di layar di atas aplikasi lainnya. Ketuk tombol untuk memperbesar."</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Beralih ke tombol Aksesibilitas"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="7115794462123071594">"Gunakan ketuk tiga kali"</string>
    <string name="accessibility_magnification_triple_tap_warning_title" msgid="8484669851397296597">"Ini mungkin memperlambat keyboard Anda"</string>
    <string name="accessibility_magnification_triple_tap_warning_message" msgid="2008671502848936410">"Saat mengetuk tiga kali untuk memperbesar bagian layar, Anda mungkin menemukan masalah pada keyboard.\n\nUntuk menghindarinya, Anda dapat mengubah pintasan pembesaran dari ketuk tiga kali ke opsi lain.\n"<annotation id="link">"Ubah setelan"</annotation></string>
    <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Tetap lanjutkan"</string>
    <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Batal"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Setelan pembesaran"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3121714118381882167">"Perbesar dengan ketuk 3 kali"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Perbesar dengan pintasan"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Perbesar dengan pintasan &amp; ketuk tiga kali"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"Tentang <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_text_reading_options_title" msgid="3224648909213325563">"Ukuran tampilan dan teks"</string>
    <string name="accessibility_text_reading_options_suggestion_title" msgid="2492155642665312733">"Ubah tampilan teks"</string>
    <string name="accessibility_text_reading_preview_mail_subject" msgid="4597374768612733616">"Subjek: Desain balon udara"</string>
    <string name="accessibility_text_reading_preview_mail_from" msgid="1797499780365288020">"Dari: Budi"</string>
    <string name="accessibility_text_reading_preview_mail_content" msgid="8078152365771951802">"Selamat pagi.\n\nSaya ingin menanyakan progres desainnya. Apakah desainnya akan siap sebelum kita mulai membuat balon baru?"</string>
    <string name="accessibility_text_reading_reset_button_title" msgid="5960753279788187669">"Reset setelan"</string>
    <string name="accessibility_text_reading_reset_message" msgid="824644303661026712">"Setelan ukuran tampilan dan teks telah direset"</string>
    <string name="accessibility_text_reading_confirm_dialog_title" msgid="2865331351355690389">"Reset ukuran tampilan dan teks?"</string>
    <string name="accessibility_text_reading_confirm_dialog_reset_button" msgid="8215800137850243736">"Reset"</string>
    <string name="accessibility_text_reading_conversation_message_1" msgid="7883952203831957831">"Ada rencana weekend ini?"</string>
    <string name="accessibility_text_reading_conversation_message_2" msgid="8112160435318635856">"Pergi ke pantai. Mau ikut?"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Opsi"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Perbesar tampilan di layar"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Ketuk 3 kali untuk memperbesar"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Ketuk tombol untuk zoom"</string>
    <string name="accessibility_screen_magnification_intro_text" msgid="3856180549393526339">"Perbesar layar dengan cepat untuk membuat konten terlihat lebih besar"</string>
    <string name="accessibility_screen_magnification_summary" msgid="8267672508057326959">"&lt;b&gt;Untuk memperbesar:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Gunakan pintasan untuk memulai pembesaran&lt;br/&gt; {1,number,integer}. Ketuk layar&lt;br/&gt; {2,number,integer}. Tarik dengan 2 jari untuk berpindah pada layar&lt;br/&gt; {3,number,integer}. Cubit dengan 2 jari untuk menyesuaikan zoom&lt;br/&gt; {4,number,integer}. Gunakan pintasan untuk menghentikan pembesaran&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Untuk memperbesar sementara:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Pastikan jenis pembesaran disetel ke layar penuh&lt;br/&gt; {1,number,integer}. Gunakan pintasan untuk memulai pembesaran&lt;br/&gt; {2,number,integer}. Sentuh lama di mana pun pada layar&lt;br/&gt; {3,number,integer}. Tarik dengan jari untuk berpindah pada layar&lt;br/&gt; {4,number,integer}. Angkat jari untuk menghentikan pembesaran"</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Jika pembesaran diaktifkan, Anda dapat memperbesar tampilan layar.\n\n"<b>"Untuk memperbesar tampilan"</b>", mulai pembesaran, lalu ketuk di bagian mana saja pada layar.\n"<ul><li>"Tarik dengan 2 jari atau lebih untuk melakukan scroll"</li>\n<li>"Cubit dengan 2 jari atau lebih untuk menyesuaikan pembesaran"</li></ul>\n\n<b>"Untuk memperbesar tampilan sementara"</b>", mulai pembesaran, lalu sentuh lama di bagian mana saja pada layar.\n"<ul><li>"• Tarik untuk menggeser layar"</li>\n<li>"• Angkat jari untuk memperkecil tampilan"</li></ul>\n\n"Anda tidak dapat memperbesar keyboard atau menu navigasi."</string>
    <string name="accessibility_tutorial_pager" msgid="8461939455728454061">"Halaman <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> dari <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Gunakan tombol aksesibilitas untuk membuka"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Tahan tombol volume untuk membuka"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Ketuk tiga kali pada layar untuk membuka"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Menggunakan gestur untuk membuka"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="6800684770875867559">"Gunakan gestur aksesibilitas"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Untuk menggunakan fitur ini, ketuk tombol aksesibilitas <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> di bagian bawah layar.\n\nUntuk beralih antarfitur, sentuh lama tombol aksesibilitas."</string>
    <string name="accessibility_tutorial_dialog_message_floating_button" msgid="2551777208185138391">"Untuk menggunakan fitur ini, ketuk tombol aksesibilitas di layar."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Untuk menggunakan fitur ini, tekan dan tahan kedua tombol volume."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Untuk memulai dan menghentikan pembesaran, ketuk tiga kali di mana saja pada layar Anda."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Untuk menggunakan fitur ini, geser ke atas dari bawah layar dengan 2 jari.\n\nUntuk beralih antarfitur, geser ke atas dengan 2 jari dan tahan."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Untuk menggunakan fitur ini, geser ke atas dari bawah layar dengan 3 jari.\n\nUntuk beralih antarfitur, geser ke atas dengan 3 jari dan tahan."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Untuk menggunakan fitur aksesibilitas, geser ke atas dari bawah layar dengan 2 jari.\n\nUntuk beralih antarfitur, geser ke atas dengan 2 jari dan tahan."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Untuk menggunakan fitur aksesibilitas, geser ke atas dari bawah layar dengan 3 jari.\n\nUntuk beralih antarfitur, geser ke atas dengan 3 jari dan tahan."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"Oke"</string>
    <string name="accessibility_tutorial_dialog_link_button" msgid="1624189347106713695">"Setelan tombol aksesibilitas"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"Pintasan <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Tombol aksesibilitas"</string>
    <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Gestur aksesibilitas"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Geser layar ke atas dengan 2 jari"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Geser layar ke atas dengan 3 jari"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Ketuk tombol aksesibilitas"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture" msgid="3981188764050497346">"Gunakan gestur aksesibilitas"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Ketuk tombol aksesibilitas <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> di bagian bawah layar.\n\nUntuk beralih ke fitur lain, sentuh lama tombol aksesibilitas."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Geser ke atas dari bawah layar dengan 2 jari.\n\nUntuk beralih ke fitur lain, geser ke atas dengan 2 jari dan tahan."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Geser ke atas dari bawah layar dengan 3 jari.\n\nUntuk beralih ke fitur lain, geser ke atas dengan 3 jari dan tahan."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating" msgid="4459254227203203324"><annotation id="link">"Opsi lainnya"</annotation></string>
    <string name="footer_learn_more_content_description" msgid="8843798273152131341">"Pelajari lebih lanjut <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Tahan tombol volume"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"tahan tombol volume"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Tekan dan tahan kedua tombol volume"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Ketuk layar tiga kali"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"ketuk layar tiga kali"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="2102327956423320536">"Ketuk layar dengan cepat {0,number,integer} kali. Pintasan ini mungkin memperlambat perangkat Anda"</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Lanjutan"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"Tombol Aksesibilitas disetel ke <xliff:g id="SERVICE">%1$s</xliff:g>. Untuk menggunakan fitur pembesaran, sentuh lama tombol Aksesibilitas, kemudian pilih pembesaran."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"Gestur aksesibilitas disetel ke <xliff:g id="SERVICE">%1$s</xliff:g>. Untuk menggunakan pembesaran, geser ke atas dengan dua jari dari bagian bawah layar dan tahan. Lalu, pilih pembesaran."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Pintasan tombol volume"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Setelan pintasan"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Pintasan dari layar kunci"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Izinkan pintasan fitur diaktifkan dari layar kunci. Tahan kedua tombol volume selama beberapa detik."</string>
    <string name="accessibility_button_title" msgid="5251235485581552614">"Tombol aksesibilitas"</string>
    <string name="accessibility_button_gesture_title" msgid="3573456209050374139">"Tombol &amp; gestur aksesibilitas"</string>
    <string name="accessibility_button_intro_text" msgid="80993874471745687">"Akses fitur aksesibilitas dengan cepat dari layar mana pun"</string>
    <string name="accessibility_button_about_title" msgid="3581116105084067926">"Tentang tombol aksesibilitas"</string>
    <string name="accessibility_button_gesture_about_title" msgid="8468987303602865536">"Tentang tombol aksesibilitas &amp; gestur"</string>
    <string name="accessibility_button_gesture_footer_learn_more_content_description" msgid="4144803517680297869">"Pelajari tombol aksesibilitas &amp; gestur lebih lanjut"</string>
    <string name="accessibility_button_intro" msgid="2601976470525277903">"Menggunakan tombol aksesibilitas. Gestur tidak tersedia dengan navigasi 3 tombol."</string>
    <string name="accessibility_button_summary" msgid="8510939012631455831">"Akses fitur aksesibilitas dengan cepat"</string>
    <string name="accessibility_button_gesture_description" msgid="7507097717493960397"><b>"Untuk memulai"</b>\n"1. Buka setelan aksesibilitas\n2. Pilih salah satu fitur, lalu ketuk pintasan\n3. Pilih apakah Anda ingin menggunakan tombol atau gestur untuk mengakses fitur tersebut"</string>
    <string name="accessibility_button_description" msgid="1261273371298608222"><b>"Untuk memulai"</b>\n"1. Buka setelan aksesibilitas\n2. Pilih salah satu fitur, lalu ketuk pintasan\n3. Pilih tombol untuk mengakses fitur tersebut"</string>
    <string name="accessibility_button_or_gesture_title" msgid="3510075963401163529">"Gunakan tombol atau gestur"</string>
    <string name="accessibility_button_location_title" msgid="7182107846092304942">"Lokasi"</string>
    <string name="accessibility_button_size_title" msgid="5785110470538960881">"Ukuran"</string>
    <string name="accessibility_button_fade_title" msgid="8081993897680588829">"Memudar saat tidak digunakan"</string>
    <string name="accessibility_button_fade_summary" msgid="7865950833524973709">"Memudar setelah beberapa detik sehingga layar lebih mudah dilihat"</string>
    <string name="accessibility_button_opacity_title" msgid="4727355657530362289">"Transparansi saat tidak digunakan"</string>
    <string name="accessibility_button_low_label" msgid="4193015407828927741">"Transparan"</string>
    <string name="accessibility_button_high_label" msgid="9138077512008190896">"Tidak transparan"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Teks kontras tinggi"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Ubah warna teks ke hitam atau putih. Memaksimalkan kontras dengan latar belakang."</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Perbarui otomatis pembesaran layar"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Perbarui pembesaran layar di transisi aplikasi"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Tombol daya untuk tutup telepon"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Kursor mouse besar"</string>
    <string name="accessibility_toggle_large_pointer_icon_summary" msgid="1480527946039237705">"Membuat kursor mouse lebih mudah dilihat"</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Hapus animasi"</string>
    <string name="accessibility_disable_animations_summary" msgid="5828228669556554565">"Kurangi gerakan di layar"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Audio mono"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Gabungkan saluran saat memutar audio"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Keseimbangan audio"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Kiri"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Kanan"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Default"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"10 detik"</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"30 detik"</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"1 menit"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 menit"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Waktu ambil tindakan (Waktu tunggu aksesibilitas)"</string>
    <string name="accessibility_control_timeout_about_title" msgid="813588002683460837">"Tentang waktu ambil tindakan (Waktu tunggu aksesibilitas)"</string>
    <string name="accessibility_control_timeout_footer_learn_more_content_description" msgid="8118584413220542193">"Pelajari waktu ambil tindakan lebih lanjut (Waktu tunggu aksesibilitas)"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Waktu ambil tindakan"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="4037051091059316310">"Preferensi pengaturan waktu ini didukung di aplikasi tertentu"</string>
    <string name="accessibility_control_timeout_preference_intro_text" msgid="1398116710556762245">"Pilih durasi tampilan pesan sementara yang perlu ditindak"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Jeda sentuh lama"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Inversi warna"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Gunakan inversi warna"</string>
    <string name="accessibility_display_inversion_shortcut_title" msgid="6889624526691513462">"Pintasan inversi warna"</string>
    <string name="accessibility_display_inversion_preference_intro_text" msgid="1159663288481145318">"Inversi warna mengubah layar terang menjadi gelap. Fitur ini juga mengubah layar gelap menjadi terang."</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="4494767676482389509">"&lt;b&gt;Perlu diperhatikan&lt;/b&gt;&lt;br/&gt; &lt;ol&gt; &lt;li&gt; Warna akan berubah pada media dan gambar&lt;/li&gt; &lt;li&gt; Inversi warna berfungsi di semua aplikasi&lt;/li&gt; &lt;li&gt; Untuk menampilkan latar belakang gelap, gunakan Tema gelap saja&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Klik otomatis (lama singgah)"</string>
    <string name="accessibility_autoclick_about_title" msgid="152923024405552594">"Tentang klik otomatis (lama singgah)"</string>
    <string name="accessibility_autoclick_footer_learn_more_content_description" msgid="7056189627042350691">"Pelajari klik otomatis lebih lanjut (lama singgah)"</string>
    <string name="accessibility_autoclick_intro_text" msgid="8959680635470639347">"Anda dapat menyetel mouse yang terhubung agar mengklik secara otomatis jika kursor berhenti bergerak selama jangka waktu tertentu"</string>
    <string name="accessibility_autoclick_description" msgid="6695732131412361101">"Klik otomatis dapat berguna jika Anda kesulitan mengklik mouse"</string>
    <string name="accessibility_autoclick_default_title" msgid="2024730028293793490">"Klik otomatis nonaktif"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Singkat"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0,2 detik"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Sedang"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0,6 detik"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Lama"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"1 detik"</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Kustom"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Lebih singkat"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Lebih lama"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Waktu klik otomatis"</string>
    <string name="accessibility_vibration_settings_title" msgid="936301142478631993">"Getaran &amp; sentuhan"</string>
    <string name="accessibility_vibration_settings_summary" msgid="3690308537483465527">"Kontrol kekuatan getaran untuk penggunaan yang berbeda"</string>
    <string name="accessibility_vibration_settings_state_on" msgid="5566026932372832502">"Aktif"</string>
    <string name="accessibility_vibration_settings_state_off" msgid="7946588741954981703">"Nonaktif"</string>
    <string name="accessibility_vibration_setting_disabled_for_silent_mode_summary" msgid="3982701772953323190">"Setelan dinonaktifkan karena perangkat disetel ke senyap"</string>
    <string name="accessibility_call_vibration_category_title" msgid="2545607568768192318">"Panggilan telepon"</string>
    <string name="accessibility_notification_alarm_vibration_category_title" msgid="2683635252414849417">"Notifikasi dan alarm"</string>
    <string name="accessibility_interactive_haptics_category_title" msgid="3162855291184592021">"Interaksi sentuhan"</string>
    <string name="accessibility_vibration_primary_switch_title" msgid="6162579254864450592">"Gunakan getaran &amp; sentuhan"</string>
    <string name="accessibility_alarm_vibration_title" msgid="4661294337828522745">"Getaran alarm"</string>
    <string name="accessibility_media_vibration_title" msgid="1372073715403945428">"Getaran media"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Getaran dering"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Getaran notifikasi"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Respons sentuhan"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"Gunakan <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"Buka <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> ditambahkan ke Setelan Cepat. Geser ke bawah untuk mengaktifkan atau menonaktifkannya kapan saja."</string>
    <string name="accessibility_service_qs_tooltip_content" msgid="6002493441414967868">"Anda juga dapat menambahkan <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> ke Setelan Cepat dari bagian atas layar"</string>
    <string name="accessibility_color_correction_auto_added_qs_tooltip_content" msgid="9092661358437404374">"Koreksi warna ditambahkan ke Setelan Cepat. Geser ke bawah untuk mengaktifkan atau menonaktifkannya kapan saja."</string>
    <string name="accessibility_color_correction_qs_tooltip_content" msgid="3258628434235475205">"Anda juga dapat menambahkan koreksi warna ke Setelan Cepat dari bagian atas layar"</string>
    <string name="accessibility_color_inversion_auto_added_qs_tooltip_content" msgid="7267618234972101725">"Inversi warna ditambahkan ke Setelan Cepat. Geser ke bawah untuk mengaktifkan atau menonaktifkannya kapan saja."</string>
    <string name="accessibility_color_inversion_qs_tooltip_content" msgid="5046332142185711869">"Anda juga dapat menambahkan inversi warna ke Setelan Cepat dari bagian atas layar"</string>
    <string name="accessibility_reduce_bright_colors_auto_added_qs_tooltip_content" msgid="1906588335786328512">"Ekstra redup ditambahkan ke Setelan Cepat. Geser ke bawah untuk mengaktifkan atau menonaktifkannya kapan saja."</string>
    <string name="accessibility_reduce_bright_colors_qs_tooltip_content" msgid="7522121299176176785">"Anda juga dapat menambahkan ekstra redup ke Setelan Cepat dari bagian atas layar"</string>
    <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content" msgid="7914554254280416532">"Mode satu tangan ditambahkan ke Setelan Cepat. Geser ke bawah untuk mengaktifkan atau menonaktifkannya kapan saja."</string>
    <string name="accessibility_one_handed_mode_qs_tooltip_content" msgid="2754332083184384603">"Anda juga dapat menambahkan mode satu tangan ke Setelan Cepat dari bagian atas layar"</string>
    <string name="accessibility_font_scaling_auto_added_qs_tooltip_content" msgid="7229921960884718332">"Ukuran font ditambahkan ke Setelan Cepat. Geser ke bawah untuk mengubah ukuran font kapan saja."</string>
    <string name="accessibility_quick_settings_tooltip_dismiss" msgid="3269120277643884190">"Tutup"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Gunakan koreksi warna"</string>
    <string name="accessibility_daltonizer_shortcut_title" msgid="7480360363995502369">"Pintasan koreksi warna"</string>
    <string name="accessibility_daltonizer_about_title" msgid="6063650804116981287">"Tentang koreksi warna"</string>
    <string name="accessibility_daltonizer_footer_learn_more_content_description" msgid="2091679253892040910">"Pelajari koreksi warna lebih lanjut"</string>
    <string name="accessibility_color_inversion_about_title" msgid="8275754480247040136">"Tentang inversi warna"</string>
    <string name="accessibility_color_inversion_footer_learn_more_content_description" msgid="5382579548498952445">"Pelajari inversi warna lebih lanjut"</string>
    <string name="accessibility_captioning_primary_switch_title" msgid="3663677340286206100">"Tampilkan teks"</string>
    <string name="accessibility_captioning_primary_switch_summary" msgid="2544094070306830218">"Hanya untuk aplikasi yang didukung"</string>
    <string name="captioning_appearance_title" msgid="3128792092290011408">"Ukuran dan gaya teks"</string>
    <string name="captioning_appearance_summary" msgid="4620682807315588019">"Ukuran teks <xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g>"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Opsi lainnya"</string>
    <string name="accessibility_captioning_preference_intro" msgid="8995427146374031134">"Sesuaikan ukuran dan gaya teks agar lebih mudah dibaca"</string>
    <string name="accessibility_captioning_preference_summary" msgid="8335768472978374255">"Preferensi teks ini didukung di aplikasi media tertentu"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Tombol aksesibilitas"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"geser dengan 2 jari dari bawah ke atas"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Tahan tombol volume"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Ketuk layar tiga kali"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Lanjutkan"</string>
    <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Alat bantu dengar"</string>
    <string name="accessibility_hearingaid_intro" msgid="5856992709195963850">"Anda dapat menggunakan alat bantu dengar, implan koklea, dan perangkat amplifikasi lainnya dengan ponsel"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Tidak ada alat bantu dengar yang terhubung"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Tambahkan alat bantu dengar"</string>
    <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Sambungkan ke alat bantu dengar"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="581652489109350119">"Pada layar berikutnya, ketuk alat bantu dengar Anda. Alat untuk telinga kiri dan kanan mungkin perlu disambungkan secara terpisah.\n\nPastikan alat bantu dengar Anda dinyalakan dan siap disambungkan."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> aktif"</string>
    <string name="accessibility_hearingaid_left_side_device_summary" msgid="1907302799168261001">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, hanya kiri"</string>
    <string name="accessibility_hearingaid_right_side_device_summary" msgid="148257064855054376">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, hanya kanan"</string>
    <string name="accessibility_hearingaid_left_and_right_side_device_summary" msgid="4268221140368164452">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, kiri dan kanan"</string>
    <string name="accessibility_hearingaid_more_device_summary" msgid="8092641784056942546">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> +1 lainnya"</string>
    <string name="accessibility_hearing_device_pairing_title" msgid="2701812183769537320">"Sambungkan alat baru"</string>
    <string name="accessibility_pair_hearing_device_about_title" msgid="5870335480815052755">"Tentang Sambungkan perangkat baru"</string>
    <string name="accessibility_hearing_device_connected_title" msgid="3785140037249487287">"Alat bantu dengar"</string>
    <string name="accessibility_hearing_device_saved_title" msgid="7573926212664909296">"Alat tersimpan"</string>
    <string name="accessibility_hearing_device_control" msgid="2661965917013100611">"Kontrol alat bantu dengar"</string>
    <string name="accessibility_hearing_device_shortcut_title" msgid="7645100199603031360">"Pintasan alat bantu dengar"</string>
    <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Kompatibilitas alat bantu dengar"</string>
    <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Meningkatkan kompatibilitas dengan telecoil dan mengurangi kebisingan yang tidak diinginkan"</string>
    <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Tentang alat bantu dengar"</string>
    <string name="accessibility_hearing_device_footer_summary" msgid="7451899224828040581">"Pastikan alat bantu dengar Anda telah diaktifkan dan siap disambungkan"</string>
    <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Sambungkan alat"</string>
    <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Alat bantu dengar yang tersedia"</string>
    <string name="accessibility_found_all_devices" msgid="7817834722148556520">"Tidak melihat alat bantu dengar Anda?"</string>
    <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"Lihat perangkat lainnya"</string>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Penyesuaian audio"</string>
    <string name="accessibility_toggle_audio_description_preference_title" msgid="8916473886256061220">"Deskripsi audio"</string>
    <string name="accessibility_audio_description_summary" msgid="2554789094873781056">"Dengarkan deskripsi tentang hal yang sedang terjadi di layar pada film dan acara TV yang mendukung deskripsi audio"</string>
    <string name="keywords_audio_description" msgid="6202816411593281252">"deskripsi audio, audio, deskripsi, gangguan penglihatan,"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Pintasan aktif"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Nonaktif"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"Aktif"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Nonaktif"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Tidak berfungsi. Ketuk untuk melihat infonya."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Layanan ini tidak berfungsi."</string>
    <string name="accessibility_shortcuts_settings_title" msgid="974740249671825145">"Pintasan aksesibilitas"</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Tampilkan di Setelan Cepat"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="4210949400493358650">"Merah-hijau"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6392456967103014723">"Merah-hijau"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="2278786218762602022">"Biru-kuning"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"Hitam putih"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="2117727423019598455">"Lemah hijau, deuteranomali"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="4617032854982040748">"Lemah merah, protanomali"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2428218320118180070">"Tritanomali"</string>
    <string name="reduce_bright_colors_preference_title" msgid="2249314004651574997">"Ekstra redup"</string>
    <string name="reduce_bright_colors_switch_title" msgid="1751678397884065312">"Buat layar ekstra redup"</string>
    <string name="reduce_bright_colors_shortcut_title" msgid="495648157059202745">"Pintasan ekstra redup"</string>
    <string name="reduce_bright_colors_about_title" msgid="503655452544934393">"Tentang ekstra redup"</string>
    <string name="reduce_bright_colors_preference_intro_text" msgid="3502290826747650566">"Membuat layar lebih redup agar Anda dapat membaca dengan lebih nyaman."</string>
    <string name="reduce_bright_colors_intensity_preference_title" msgid="7455443033955118267">"Intensitas"</string>
    <string name="reduce_bright_colors_intensity_start_label" msgid="930387498396426039">"Lebih redup"</string>
    <string name="reduce_bright_colors_intensity_end_label" msgid="1422600205484299860">"Lebih cerah"</string>
    <string name="reduce_bright_colors_persist_preference_title" msgid="4368829654993343354">"Tetap aktif setelah perangkat dimulai ulang"</string>
    <string name="accessibilty_autoclick_preference_subtitle_short_delay" msgid="2981206111858937724">"{count,plural, =1{Singkat ({time} detik)}other{Singkat ({time} detik)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_medium_delay" msgid="6867395206533459204">"{count,plural, =1{Sedang ({time} detik)}other{Sedang ({time} detik)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_long_delay" msgid="4079139970819335593">"{count,plural, =1{Lama ({time} detik)}other{Lama ({time} detik)}}"</string>
    <string name="accessibilty_autoclick_delay_unit_second" msgid="5979297390686370567">"{count,plural, =1{{time} detik}other{{time} detik}}"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Setelan"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"Aktif"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Nonaktif"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Pratinjau"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Opsi standar"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Bahasa"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Ukuran teks"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Gaya teks"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Opsi khusus"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Warna latar belakang"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Opasitas latar belakang"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Warna jendela teks"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Opasitas jendela teks"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Warna teks"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Opasitas teks"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Warna tepi"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Jenis tepi"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Jenis font"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Teks akan terlihat seperti ini"</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Default"</string>
    <string name="color_title" msgid="2511586788643787427">"Warna"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Default"</string>
    <string name="color_none" msgid="3703632796520710651">"Tidak ada"</string>
    <string name="color_white" msgid="1896703263492828323">"Putih"</string>
    <string name="color_gray" msgid="8554077329905747877">"Abu-abu"</string>
    <string name="color_black" msgid="9006830401670410387">"Hitam"</string>
    <string name="color_red" msgid="5210756997426500693">"Merah"</string>
    <string name="color_green" msgid="4400462091250882271">"Hijau"</string>
    <string name="color_blue" msgid="4997784644979140261">"Biru"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Sian"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Kuning"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Magenta"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"Izinkan <xliff:g id="SERVICE">%1$s</xliff:g> mengontrol perangkat Anda secara penuh?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"<xliff:g id="SERVICE">%1$s</xliff:g> perlu:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Karena sebuah aplikasi menghalangi permintaan izin, Setelan tidak dapat memverifikasi tanggapan Anda."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"<xliff:g id="SERVICE">%1$s</xliff:g> meminta kontrol penuh atas perangkat ini. Layanan dapat membaca layar dan bertindak atas nama pengguna yang memiliki kebutuhan aksesibilitas. Kontrol tingkat ini tidak sesuai untuk kebanyakan aplikasi."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"Kontrol penuh sesuai untuk aplikasi yang mendukung kebutuhan aksesibilitas Anda, tetapi tidak untuk sebagian besar aplikasi."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Melihat dan mengontrol layar"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"Voice Access dapat membaca semua konten di layar dan menampilkan konten di atas aplikasi lain."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Menampilkan dan melakukan tindakan"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"Voice Access dapat melacak interaksi Anda dengan aplikasi atau sensor hardware, dan berinteraksi dengan aplikasi untuk Anda."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Izinkan"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Tolak"</string>
    <string name="accessibility_dialog_button_stop" msgid="7295448112784528196">"Berhenti"</string>
    <string name="accessibility_dialog_button_cancel" msgid="4813234247237851121">"Batal"</string>
    <string name="disable_service_title" msgid="2909108731776956167">"Hentikan <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="4814173941688548016">"Mengetuk <xliff:g id="STOP">%1$s</xliff:g> akan menghentikan <xliff:g id="SERVICE">%2$s</xliff:g>."</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"Tidak ada layanan terpasang"</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"Layanan tidak dipilih"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"Tidak tersedia deskripsi."</string>
    <string name="settings_button" msgid="2195468788019730377">"Setelan"</string>
    <string name="keywords_reduce_bright_colors" msgid="1683190961013139183">"sensitivitas cahaya, fotofobia, tema gelap, migrain, sakit kepala, mode baca, mode malam, kurangi kecerahan, titik putih"</string>
    <string name="keywords_accessibility" msgid="4263443239404659143">"Kemudahan penggunaan, kemudahan akses, bantuan, asistif"</string>
    <string name="keywords_magnification" msgid="3908145308269840862">"Pembesar Jendela, Zoom, Pembesaran, Gangguan penglihatan, Perbesar, buat lebih besar"</string>
    <string name="keywords_talkback" msgid="2816435437095102527"></string>
    <string name="keywords_live_caption" msgid="1667203998080567556">"Teks, teks tertutup, CC, Transkripsi Instan, gangguan pendengaran, kerusakan pendengaran, CART, speech to text, subtitel"</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">"ukuran layar, layar besar"</string>
    <string name="keywords_bold_text" msgid="6257418169207099589">"Kontras tinggi, gangguan penglihatan, font tebal, huruf tebal"</string>
    <string name="keywords_select_to_speak" msgid="2872704811610888719"></string>
    <string name="keywords_color_correction" msgid="8540442886990423681">"sesuaikan warna"</string>
    <string name="keywords_color_inversion" msgid="4291058365873221962">"gelapkan layar, cerahkan layar"</string>
    <string name="keywords_contrast" msgid="4668393735398949873">"kontras warna"</string>
    <string name="keywords_accessibility_menu" msgid="4300579436464706608"></string>
    <string name="keywords_switch_access" msgid="5813094504384313402"></string>
    <string name="keywords_auto_click" msgid="7151756353013736931">"motorik, mouse"</string>
    <string name="keywords_hearing_aids" msgid="4550504337687223314">"alat bantu dengar, gangguan pendengaran, kehilangan pendengaran, implan koklea, perangkat amplifikasi, prosesor suara"</string>
    <string name="keywords_rtt" msgid="2429130928152514402">"gangguan pendengaran, kerusakan pendengaran, teks, Teletip, tty"</string>
    <string name="keywords_voice_access" msgid="7807335263195876454"></string>
    <string name="print_settings" msgid="8519810615863882491">"Pencetakan"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Nonaktif"</string>
    <string name="print_settings_summary" msgid="1458773840720811915">"{count,plural, =1{1 layanan cetak aktif}other{# layanan cetak aktif}}"</string>
    <string name="print_jobs_summary" msgid="7040836482336577323">"{count,plural, =1{1 tugas pencetakan}other{# tugas pencetakan}}"</string>
    <string name="print_settings_title" msgid="7680498284751129935">"Layanan cetak"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"Tidak ada layanan terpasang"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"Tidak ditemukan printer"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Setelan"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Tambahkan printer"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"Aktif"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Nonaktif"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Tambahkan layanan"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Tambahkan printer"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Telusuri"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Mencari printer"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Layanan dinonaktifkan"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Tugas pencetakan"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Tugas pencetakan"</string>
    <string name="print_restart" msgid="4424096106141083945">"Mulai Ulang"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Batal"</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">"Mengonfigurasi <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"Mencetak <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"Membatalkan <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Ada kesalahan printer <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"Printer memblokir <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Kotak telusur ditampilkan"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Kotak telusur disembunyikan"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Informasi selengkapnya tentang printer ini"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Baterai"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Apa yang menggunakan daya baterai"</string>
    <string name="power_usage_level_and_status" msgid="821521456989429593">"<xliff:g id="LEVEL">%1$s</xliff:g> - <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="6997529817917076536">"<xliff:g id="REMAIN">%1$s</xliff:g> tersisa"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> lagi agar terisi penuh"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Baterai lemah"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Izinkan aplikasi berjalan di latar belakang"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Batasi aktivitas background?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"Jika aktivitas background aplikasi dibatasi, mungkin fungsinya terganggu."</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Anda tidak dapat membatasi aplikasi karena tidak disetel untuk mengoptimalkan baterai.\n\nAktifkan pengoptimalan baterai untuk membatasi aplikasi."</string>
    <string name="manager_battery_usage_unrestricted_title" msgid="2426486290463258032">"Tidak dibatasi"</string>
    <string name="manager_battery_usage_optimized_title" msgid="8080765739761921817">"Dioptimalkan"</string>
    <string name="manager_battery_usage_restricted_title" msgid="7702863764130323118">"Dibatasi"</string>
    <string name="manager_battery_usage_unrestricted_summary" msgid="6819279865465667692">"Izinkan penggunaan baterai di latar belakang tanpa batasan. Konsumsi daya baterai mungkin lebih besar."</string>
    <string name="manager_battery_usage_optimized_summary" msgid="1332545476428039900">"Optimalkan berdasarkan penggunaan Anda. Direkomendasikan untuk sebagian besar aplikasi."</string>
    <string name="manager_battery_usage_restricted_summary" msgid="8324695640704416905">"Batasi penggunaan baterai saat di latar belakang. Aplikasi mungkin tidak berfungsi sesuai harapan. Notifikasi mungkin tertunda."</string>
    <string name="manager_battery_usage_footer" msgid="2635906573922553766">"Mengubah cara aplikasi menggunakan baterai dapat memengaruhi performanya."</string>
    <string name="manager_battery_usage_footer_limited" msgid="5180776148877306780">"Aplikasi ini memerlukan penggunaan baterai <xliff:g id="STATE">%1$s</xliff:g>."</string>
    <string name="manager_battery_usage_unrestricted_only" msgid="3646162131339418216">"tanpa batasan"</string>
    <string name="manager_battery_usage_optimized_only" msgid="7121785281913056432">"dioptimalkan"</string>
    <string name="manager_battery_usage_link_a11y" msgid="374918091821438564">"Pelajari lebih lanjut opsi penggunaan baterai"</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Penggunaan layar sejak pengisian baterai penuh terakhir"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Penggunaan baterai"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Detail histori"</string>
    <string name="advanced_battery_preference_title" msgid="3790901207877260883">"Penggunaan baterai"</string>
    <string name="advanced_battery_preference_summary_with_hours" msgid="954091349133320955">"Melihat penggunaan selama 24 jam terakhir"</string>
    <string name="advanced_battery_preference_summary" msgid="2372763700477268393">"Lihat penggunaan sejak terakhir penuh"</string>
    <string name="battery_details_title" msgid="3289680399291090588">"Penggunaan baterai aplikasi"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Detail penggunaan"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Sesuaikan penggunaan daya"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Termasuk paket"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Aplikasi berjalan normal"</string>
    <string name="battery_tip_low_battery_title" msgid="4155239078744100997">"Tingkat daya baterai rendah"</string>
    <string name="battery_tip_low_battery_summary" msgid="2629633757244297436">"Aktifkan Penghemat Baterai untuk memperpanjang masa pakai baterai"</string>
    <string name="battery_tip_smart_battery_title" msgid="8925025450214912325">"Tingkatkan masa pakai baterai"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Aktifkan Pengelola Baterai"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Aktifkan Penghemat Baterai"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"Baterai mungkin lebih cepat habis dari biasanya"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="7705597228709143337">"Penghemat Baterai aktif"</string>
    <string name="battery_saver_link_a11y" msgid="6613079613524512257">"Pelajari Penghemat Baterai lebih lanjut"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Beberapa fitur mungkin dibatasi"</string>
    <string name="battery_tip_high_usage_title" msgid="9110720762506146697">"Penggunaan baterai tinggi"</string>
    <string name="battery_tip_high_usage_summary" msgid="3938999581403084551">"Lihat aplikasi dengan penggunaan tertinggi"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="6258554134146272311">"Pengisian daya dioptimalkan untuk melindungi baterai"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="5107379280241187562">"Untuk membantu memperpanjang masa pakai baterai, pengisian daya dioptimalkan"</string>
    <string name="battery_tip_dock_defender_future_bypass_title" msgid="4332616280495788195">"Pengisian daya dioptimalkan untuk melindungi baterai"</string>
    <string name="battery_tip_dock_defender_future_bypass_summary" msgid="7870758621381307597">"Untuk membantu memperpanjang masa pakai baterai, pengisian daya dioptimalkan saat dipasang ke dok"</string>
    <string name="battery_tip_dock_defender_active_title" msgid="1414785238383255699">"Pengisian daya dioptimalkan untuk melindungi baterai"</string>
    <string name="battery_tip_dock_defender_active_summary" msgid="3512082623718801459">"Untuk membantu memperpanjang masa pakai baterai, pengisian daya dioptimalkan saat dipasang ke dok"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_title" msgid="1679449361090557201">"Mengisi daya sampai penuh"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_summary" msgid="1099500476761333281">"Untuk melindungi baterai, pengisian daya akan dioptimalkan saat berikutnya tablet dipasang ke dok"</string>
    <string name="battery_tip_limited_temporarily_sec_button_content_description" msgid="5648444926736883551">"Pelajari lebih lanjut pengisian daya dijeda"</string>
    <string name="battery_tip_limited_temporarily_dialog_resume_charge" msgid="2302295458913832342">"Lanjutkan pengisian daya"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Termasuk aktivitas latar belakang yang menggunakan banyak daya"</string>
    <string name="battery_tip_restrict_title" msgid="4537101947310626753">"{count,plural, =1{Batasi # aplikasi}other{Batasi # aplikasi}}"</string>
    <string name="battery_tip_restrict_handled_title" msgid="7142074986508706853">"{count,plural, =1{{label} baru-baru ini dibatasi}other{# aplikasi baru-baru ini dibatasi}}"</string>
    <string name="battery_tip_restrict_summary" msgid="7539469590829235277">"{count,plural, =1{{label} menggunakan banyak baterai di latar belakang}other{# aplikasi menggunakan banyak baterai di latar belakang}}"</string>
    <string name="battery_tip_restrict_handled_summary" msgid="3535697154547199190">"{count,plural, =1{Aplikasi ini tidak dapat berjalan di latar belakang}other{Aplikasi ini tidak dapat berjalan di latar belakang}}"</string>
    <string name="battery_tip_restrict_app_dialog_title" msgid="1649476357343160240">"{count,plural, =1{Batasi aplikasi?}other{Batasi # aplikasi?}}"</string>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"Untuk menghemat baterai, hentikan <xliff:g id="APP">%1$s</xliff:g> menggunakan baterai di latar belakang. Aplikasi ini mungkin tidak berfungsi dengan baik dan notifikasi dapat tertunda."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"Untuk menghemat baterai, hentikan aplikasi ini menggunakan baterai di latar belakang. Aplikasi yang dibatasi mungkin tidak berfungsi dengan baik dan notifikasi dapat tertunda.\n\nAplikasi:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"Untuk menghemat baterai, hentikan aplikasi ini menggunakan baterai di latar belakang. Aplikasi yang dibatasi mungkin tidak berfungsi dengan baik dan notifikasi dapat tertunda.\n\nAplikasi:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Batasi"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Hapus batasan?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"Aplikasi ini dapat menggunakan baterai di latar belakang. Baterai mungkin lebih cepat habis dari biasanya."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Hapus"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Batal"</string>
    <string name="battery_tip_charge_to_full_button" msgid="6701709034348116261">"Isi daya sampai penuh"</string>
    <string name="battery_tip_incompatible_charging_title" msgid="5120763575150751300">"Masalah dengan aksesori pengisian daya"</string>
    <string name="battery_tip_incompatible_charging_content_description" msgid="355668467640367701">"Pelajari lebih lanjut mengisi daya dengan pengisi daya yang tidak kompatibel"</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Pengelola Baterai"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Kelola aplikasi secara otomatis"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Jika Pengelola Baterai mendeteksi bahwa aplikasi menghabiskan baterai, Anda akan memiliki opsi untuk membatasi aplikasi tersebut. Aplikasi yang dibatasi mungkin tidak berfungsi dengan baik dan notifikasi dapat tertunda."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Aplikasi yang dibatasi"</string>
    <string name="restricted_app_summary" msgid="1022307922754893997">"{count,plural, =1{Membatasi penggunaan baterai untuk # aplikasi}other{Membatasi penggunaan baterai untuk # aplikasi}}"</string>
    <string name="restricted_app_time_summary" msgid="3097721884155913252">"Dibatasi <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="3495725286882138803">"Aplikasi ini dibatasi dari penggunaan baterai di latar belakang. Aplikasi mungkin tidak berfungsi seperti yang diperkirakan, dan notifikasi dapat tertunda."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Gunakan Pengelola Baterai"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Mendeteksi jika aplikasi menghabiskan baterai"</string>
    <string name="battery_manager_summary" msgid="255708681438809287">"Mendeteksi saat aplikasi menghabiskan baterai"</string>
    <string name="battery_manager_summary_unsupported" msgid="7334173707292807964">"Mendeteksi saat aplikasi menghabiskan daya baterai"</string>
    <string name="battery_manager_app_restricted" msgid="2583902700677009173">"{count,plural, =1{# aplikasi dibatasi}other{# aplikasi dibatasi}}"</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">"Terjadi error saat membaca indikator baterai."</string>
    <string name="battery_missing_link_message" msgid="6021565067124898074"></string>
    <string name="battery_missing_link_a11y_message" msgid="3310971406602316323">"Ketuk untuk mempelajari error ini lebih lanjut"</string>
    <string name="power_screen" msgid="4596900105850963806">"Layar"</string>
    <string name="power_cpu" msgid="1820472721627148746">"CPU"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Lampu senter"</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">"Jaringan seluler"</string>
    <string name="power_phone" msgid="2768396619208561670">"Panggilan suara"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Penggunaan layar <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<xliff:g id="PERCENT">%1$s</xliff:g> digunakan oleh <xliff:g id="APP">%2$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> dari seluruh penggunaan baterai"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Penggunaan baterai sejak terakhir kali terisi penuh"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Pengisian baterai penuh terakhir"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"Baterai penuh bertahan sekitar"</string>
    <string name="battery_footer_summary" msgid="6753248007004259000">"Sisa masa pakai baterai merupakan hasil perkiraan dan dapat berubah berdasarkan penggunaan"</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Penggunaan baterai"</string>
    <string name="battery_not_usage" msgid="3851536644733662392">"Tidak ada penggunaan sejak terakhir kali baterai terisi penuh"</string>
    <string name="battery_not_usage_24hr" msgid="8397519536160741248">"Tidak ada penggunaan selama 24 jam terakhir"</string>
    <string name="battery_usage_without_time" msgid="1346894834339420538"></string>
    <string name="battery_usage_since_last_full_charge" msgid="3488425008925924769">"sejak terakhir kali baterai terisi penuh"</string>
    <string name="battery_usage_system_apps" msgid="8659537819731575299">"Aplikasi sistem"</string>
    <string name="battery_usage_others" msgid="311793281613609986">"Lainnya"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Perkiraan sisa waktu"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Sampai terisi penuh"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"Perkiraan dapat berubah berdasarkan penggunaan"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Mediaserver"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Pengoptimalan aplikasi"</string>
    <string name="process_network_tethering" msgid="6822671758152900766">"Tethering"</string>
    <string name="process_removed_apps" msgid="6544406592678476902">"Aplikasi yang dihapus"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Penghemat Baterai"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Aktifkan otomatis"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Tidak ada jadwal"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Berdasarkan rutinitas Anda"</string>
    <string name="battery_saver_pref_auto_routine_summary" msgid="4739240095966241508">"Akan diaktifkan berdasarkan rutinitas"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Berdasarkan persentase"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Penghemat Baterai akan aktif jika baterai kemungkinan akan habis sebelum waktu pengisian daya biasanya"</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Akan aktif saat baterai <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Setel jadwal"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Memperpanjang masa pakai baterai"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Nonaktifkan saat daya penuh"</string>
    <string name="battery_saver_sticky_title_percentage" msgid="1178162022087559148">"Nonaktifkan pada <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" msgid="6472610662679038342">"Penghemat Baterai dinonaktifkan saat baterai mencapai <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">"Aktifkan"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Gunakan Penghemat Baterai"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Aktifkan secara otomatis"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Tidak pernah"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"jika <xliff:g id="PERCENT">%1$s</xliff:g> baterai"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Persentase baterai"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Tampilkan persentase baterai di status bar"</string>
    <string name="battery_usage_chart_graph_hint_last_full_charge" msgid="6570336408060566877">"Level baterai sejak terakhir kali terisi penuh"</string>
    <string name="battery_usage_chart_graph_hint" msgid="9182079098173323005">"Tingkat daya baterai selama 24 jam terakhir"</string>
    <string name="battery_app_usage" msgid="8976453608783133770">"Penggunaan aplikasi sejak terakhir kali baterai terisi penuh"</string>
    <string name="battery_app_usage_for_past_24" msgid="1234770810563940656">"Penggunaan aplikasi selama 24 jam terakhir"</string>
    <string name="battery_system_usage" msgid="1395943945140097585">"Penggunaan sistem sejak terakhir kali baterai terisi penuh"</string>
    <string name="battery_system_usage_for_past_24" msgid="3341520273114616263">"Penggunaan sistem selama 24 jam terakhir"</string>
    <string name="battery_system_usage_for" msgid="3248552137819897140">"Penggunaan sistem untuk <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_app_usage_for" msgid="7309909074935858949">"Penggunaan aplikasi untuk <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_system_usage_since_last_full_charge_to" msgid="4196795733829841971">"Penggunaan sistem sejak terakhir kali baterai terisi penuh sampai <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_app_usage_since_last_full_charge_to" msgid="4339201995118102114">"Penggunaan aplikasi sejak terakhir kali baterai terisi penuh sampai <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_usage_total_less_than_one_minute" msgid="1035425863251685509">"Total: kurang dari satu menit"</string>
    <string name="battery_usage_background_less_than_one_minute" msgid="3957971442554437909">"Latar belakang: kurang dari satu menit"</string>
    <string name="battery_usage_screen_time_less_than_one_minute" msgid="2911989465891679033">"Waktu pemakaian perangkat: kurang dari satu menit"</string>
    <string name="battery_usage_for_total_time" msgid="8402254046930910905">"Total: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_for_background_time" msgid="9109637210617095188">"Latar belakang: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_time" msgid="3973865893520804115">"Waktu pemakaian perangkat: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer_empty" msgid="3301144846133808193">"Data penggunaan baterai akan tersedia dalam beberapa jam setelah baterai terisi penuh"</string>
    <string name="battery_usage_chart_label_now" msgid="4598282721949430165">"sekarang"</string>
    <string name="battery_usage_timestamps_hyphen" msgid="7401188432989043905">"<xliff:g id="FROM_TIMESTAMP">%1$s</xliff:g> - <xliff:g id="TO_TIMESTAMP">%2$s</xliff:g>"</string>
    <string name="battery_usage_day_and_hour" msgid="1417890420844950881">"<xliff:g id="DAY">%1$s</xliff:g> <xliff:g id="HOUR">%2$s</xliff:g>⁠"</string>
    <string name="battery_usage_chart" msgid="4114747521432440017">"Diagram penggunaan baterai"</string>
    <string name="daily_battery_usage_chart" msgid="4176059567682992686">"Diagram penggunaan baterai per hari"</string>
    <string name="hourly_battery_usage_chart" msgid="3098314511076561272">"Diagram penggunaan baterai per jam"</string>
    <string name="battery_usage_breakdown_title_since_last_full_charge" msgid="435006273323199906">"Penggunaan baterai sejak terakhir kali terisi penuh"</string>
    <string name="battery_usage_breakdown_title_for_slot" msgid="4823179483667671406">"Penggunaan baterai <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="screen_time_category_last_full_charge" msgid="8856908320256057753">"Waktu pemakaian perangkat sejak terakhir kali baterai terisi penuh"</string>
    <string name="screen_time_category_for_slot" msgid="8287722270554654959">"Waktu pemakaian perangkat <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_spinner_view_by_apps" msgid="8769276544072098082">"Lihat menurut aplikasi"</string>
    <string name="battery_usage_spinner_view_by_systems" msgid="7904104223212160541">"Lihat menurut sistem"</string>
    <string name="battery_usage_less_than_percent" msgid="5873099028895001082">"&lt; <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Statistik Proses"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Statistik teknis tentang proses yang berjalan"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Penggunaan memori"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"<xliff:g id="USEDRAM">%1$s</xliff:g> dari <xliff:g id="TOTALRAM">%2$s</xliff:g> digunakan selama <xliff:g id="TIMEDURATION">%3$s</xliff:g> terakhir"</string>
    <string name="process_stats_total_duration_percentage" msgid="4391502694312709148">"<xliff:g id="PERCENT">%1$s</xliff:g> RAM digunakan selama <xliff:g id="TIMEDURATION">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="4094034441562453522">"Latar Belakang"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"Latar Depan"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"Dalam Cache"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"OS Android"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Asli"</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">"Cache"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"Penggunaan RAM"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"Penggunaan RAM (latar belakang)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Waktu berjalan"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Proses"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Layanan"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Durasi"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Detail memori"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 jam"</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"6 jam"</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"12 jam"</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"1 hari"</string>
    <string name="menu_show_system" msgid="3780310384799907818">"Tampilkan sistem"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Sembunyikan sistem"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Tampilkan persentase"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"Gunakan Uss"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Jenis statistik"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"Latar Belakang"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"Latar Depan"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"Dalam Cache"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Masukan suara &amp; keluaran"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Masukan suara &amp; setelan keluaran"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Penelusuran suara"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Keyboard Android"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Setelan masukan suara"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Input suara"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Layanan masukan suara"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Frasa pengaktif dan interaksi lengkap"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Speech to text yang sederhana"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"Layanan masukan suara ini akan dapat melakukan pemantauan suara yang selalu aktif dan mengontrol aplikasi yang aktif untuk suara atas nama Anda. Layanan ini berasal dari aplikasi <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Aktifkan penggunaan layanan ini?"</string>
    <string name="on_device_recognition_settings" msgid="6503160369314598069">"Setelan pengenalan di perangkat"</string>
    <string name="on_device_recognition_settings_title" msgid="7137599722039096545">"Pengenalan di perangkat"</string>
    <string name="on_device_recognition_settings_summary" msgid="3292736423223499348">"Pengenalan ucapan di perangkat"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Mesin yang dipilih"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Setelan mesin"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Kecepatan bicara &amp; tinggi nada"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Mesin"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Suara"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Bahasa Lisan"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Menginstal Suara"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Lanjutkan aplikasi <xliff:g id="TTS_APP_NAME">%s</xliff:g> untuk menginstal suara"</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"Buka Aplikasi"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Batal"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Reset"</string>
    <string name="tts_play" msgid="2945513377250757221">"Putar"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"VPN"</string>
    <string name="vpn_settings_insecure_single" msgid="9012504179995045195">"Tidak aman"</string>
    <string name="vpn_settings_single_insecure_multiple_total" msgid="6107225844641301139">"<xliff:g id="VPN_COUNT">%d</xliff:g> tidak aman"</string>
    <string name="vpn_settings_multiple_insecure_multiple_total" msgid="1706236062478680488">"<xliff:g id="VPN_COUNT">%d</xliff:g> tidak aman"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Konektivitas adaptif"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Perpanjang masa pakai baterai dan tingkatkan performa perangkat dengan mengelola koneksi jaringan Anda secara otomatis"</string>
    <string name="adaptive_connectivity_switch_on" msgid="3653067561620745493">"Aktif"</string>
    <string name="adaptive_connectivity_switch_off" msgid="5076172560836115265">"Nonaktif"</string>
    <string name="adaptive_connectivity_main_switch_title" msgid="261045483524512420">"Gunakan konektivitas adaptif"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Penyimpanan kredensial"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Instal sertifikat"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Hapus kredensial"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Hapus semua sertifikat"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Kredensial tepercaya"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Tampilkan sertifikat CA tepercaya"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Kredensial pengguna"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Lihat dan ubah kredensial yang tersimpan"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Lanjutan"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Kredensial tidak tersedia untuk pengguna ini"</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Diinstal untuk VPN dan aplikasi"</string>
    <string name="credential_for_wifi" msgid="2286560570630763556">"Diinstal untuk Wi-Fi"</string>
    <string name="credential_for_wifi_in_use" msgid="7276290656840986618">"Diinstal untuk Wi‑Fi (Sedang digunakan)"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Hapus semua konten?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Penyimpanan kredensial dihapus."</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Penyimpanan kredensial tidak dapat dihapus."</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Apl dengan akses penggunaan"</string>
    <string name="ca_certificate" msgid="3076484307693855611">"Sertifikat CA"</string>
    <string name="user_certificate" msgid="6897024598058566466">"Sertifikat pengguna apl &amp; VPN"</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"Sertifikat Wi‑Fi"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Data Anda tidak akan bersifat pribadi"</string>
    <string name="ca_certificate_warning_description" msgid="8409850109551028774">"Sertifikat CA digunakan oleh situs, aplikasi, dan VPN untuk enkripsi. Hanya instal Sertifikat CA dari organisasi yang Anda percaya. \n\nJika Anda menginstal Sertifikat CA, pemilik sertifikat tersebut dapat mengakses data Anda, seperti sandi atau detail kartu kredit, dari situs yang Anda buka atau aplikasi yang Anda gunakan – meskipun jika data Anda dienkripsi."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Jangan instal"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Tetap instal"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Sertifikat tidak diinstal"</string>
    <string name="request_manage_credentials_title" msgid="596805634568013413">"Izinkan "<b>"<xliff:g id="APP_NAME">^1</xliff:g>"</b>" menginstal sertifikat di perangkat ini?"</string>
    <string name="request_manage_credentials_description" msgid="8044839857171509619">"Sertifikat ini akan memverifikasi Anda dengan membagikan ID unik perangkat Anda ke aplikasi dan URL di bawah ini"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Jangan izinkan"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Izinkan"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Tampilkan lebih banyak"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"Aplikasi pengelola sertifikat"</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Tidak ada"</string>
    <string name="certificate_management_app_description" msgid="8507306554200869005">"Sertifikat akan memverifikasi Anda saat menggunakan aplikasi dan URL di bawah ini"</string>
    <string name="uninstall_certs_credential_management_app" msgid="4945883254446077354">"Uninstal sertifikat"</string>
    <string name="remove_credential_management_app" msgid="6089291496976812786">"Hapus aplikasi"</string>
    <string name="remove_credential_management_app_dialog_title" msgid="5713525435104706772">"Hapus aplikasi ini?"</string>
    <string name="remove_credential_management_app_dialog_message" msgid="7739474298063646935">"Aplikasi ini tidak akan mengelola sertifikat, tetapi akan tetap ada di perangkat Anda. Sertifikat apa pun yang diinstal oleh aplikasi ini akan di-uninstal."</string>
    <string name="number_of_urls" msgid="1128699121050872188">"{count,plural, =1{# URL}other{# URL}}"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Sinyal panggilan darurat"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Setel perilaku ketika panggilan darurat dilakukan"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Pencadangan"</string>
    <string name="backup_summary_state_on" msgid="9018954639693085240">"Aktif"</string>
    <string name="backup_summary_state_off" msgid="5341339397224835909">"Nonaktif"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Pencadangan &amp; pemulihan"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Data pribadi"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Cadangkan data saya"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"Mencadangkan data aplikasi, sandi Wi-Fi, dan setelan lainnya ke server Google"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Akun pencadangan"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Kelola akun pencadangan"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Sertakan data aplikasi"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Pemulihan otomatis"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"Pulihkan cadangan setelan dan data saat menginstal ulang aplikasi"</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Layanan pencadangan tidak aktif"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Saat ini, tidak ada akun yang menyimpan data cadangan"</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"Berhenti mencadangkan sandi Wi-Fi, bookmark, setelan lainnya, dan data aplikasi, serta menghapus semua salinan di server Google?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="2379053988557486162">"Berhenti mencadangkan data perangkat (seperti sandi Wi-Fi dan histori panggilan) dan data aplikasi (seperti setelan dan file yang disimpan oleh aplikasi), serta hapus semua salinan di server jarak jauh?"</string>
    <string name="fullbackup_data_summary" msgid="971587401251601473">"Otomatis cadangkan data perangkat (seperti sandi Wi-Fi dan histori panggilan) dan data aplikasi (seperti setelan dan file yang disimpan oleh aplikasi) dari jarak jauh.\n\nJika Anda mengaktifkan cadangan otomatis, data perangkat dan aplikasi secara berkala disimpan dari jarak jauh. Data aplikasi dapat berupa data apa saja yang telah disimpan oleh aplikasi (menurut setelan developer), termasuk data yang berpotensi sensitif seperti kontak, pesan, dan foto."</string>
    <string name="device_admin_settings_title" msgid="31392408594557070">"Setelan admin perangkat"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"Aplikasi admin perangkat"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Nonaktifkan aplikasi admin perangkat ini"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Uninstal aplikasi"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Nonaktifkan &amp; uninstal"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Aplikasi admin perangkat"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"Tidak ada aplikasi admin yang tersedia"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"Tidak tersedia perangkat tepercaya"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Aktifkan aplikasi admin perangkat?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Aktifkan aplikasi admin perangkat ini"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Admin perangkat"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Mengaktifkan aplikasi admin ini akan mengizinkan aplikasi <xliff:g id="APP_NAME">%1$s</xliff:g> menjalankan operasi berikut:"</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"Perangkat ini akan dikelola dan dipantau oleh <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"Aplikasi admin ini aktif dan mengizinkan aplikasi <xliff:g id="APP_NAME">%1$s</xliff:g> menjalankan operasi berikut:"</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"Aktifkan Pengelola Profil?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Izinkan pengawasan?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Dengan melanjutkan, pengguna Anda akan dikelola oleh admin yang juga dapat menyimpan data terkait, selain data pribadi Anda.\n\nAdmin dapat memantau serta mengelola setelan, akses, aplikasi, dan data terkait pengguna, termasuk aktivitas jaringan dan informasi lokasi perangkat."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"Opsi lainnya dinonaktifkan oleh admin."</string>
    <string name="admin_more_details" msgid="4928985331640193758">"Pelajari lebih lanjut"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Log notifikasi"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Histori notifikasi"</string>
    <string name="notification_history_today" msgid="6081829638548808795">"%d jam terakhir"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Ditunda"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Baru-baru ini ditutup"</string>
    <string name="notification_history_count" msgid="885305572972482838">"{count,plural, =1{# notifikasi}other{# notifikasi}}"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Nada dering &amp; getar panggilan"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Detail jaringan"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Sinkronisasi diaktifkan"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Sinkronisasi dinonaktifkan"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Sedang menyinkronkan"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Kesalahan sinkronisasi."</string>
    <string name="sync_failed" msgid="3806495232114684984">"Sinkronisasi gagal"</string>
    <string name="sync_active" msgid="5787407579281739975">"Sinkronisasi aktif"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Sinkronisasi"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"Saat ini sinkronisasi mengalami masalah. Sinkronisasi akan segera berfungsi kembali."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Tambahkan akun"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Profil kerja belum tersedia"</string>
    <string name="work_mode_label" msgid="4687734487641548872">"Aplikasi kerja"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Hapus profil kerja"</string>
    <string name="background_data" msgid="321903213000101158">"Data latar belakang"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Apl dapat menyinkronkan, mengirimkan, dan menerima data kapan saja"</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Matikn data ltr blkg?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"Menonaktifkan data latar belakang memperpanjang masa pakai baterai dan mengurangi penggunaan data. Beberapa aplikasi mungkin masih menggunakan sambungan data latar belakang."</string>
    <string name="sync_enabled" msgid="5794103781356455043">"Sinkronisasi AKTIF"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Sinkronisasi NONAKTIF"</string>
    <string name="sync_error" msgid="846923369794727644">"Kesalahan sinkronisasi"</string>
    <string name="last_synced" msgid="1527008461298110443">"Terakhir disinkronkan <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Sedang menyinkronkan..."</string>
    <string name="settings_backup" msgid="5357973563989458049">"Setelan cadangan"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Cadangkan setelan saya"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Sinkronkan sekarang"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Batal sinkronisasi"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Ketuk untuk menyinkronkan sekarang<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="228561698646018808">"Gmail"</string>
    <string name="sync_calendar" msgid="4603704438090387251">"Kalender"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Kontak"</string>
    <string name="header_application_sync_settings" msgid="7427706834875419243">"Setelan sinkronisasi apl"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Data &amp; sinkronisasi"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Ubah sandi"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Setelan akun"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Hapus akun"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Tambahkan akun"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Hapus akun?"</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"Perubahan ini tidak diizinkan oleh admin"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Tidak dapat menyinkronkan secara manual"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"Saat ini, sinkronisasi untuk item ini dinonaktifkan. Untuk mengubah setelan ini, aktifkan data latar belakang dan sinkronisasi otomatis untuk sementara."</string>
    <string name="delete" msgid="8330605554706263775">"Hapus"</string>
    <string name="select_all" msgid="7898929601615536401">"Pilih semua"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Penggunaan data"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Data seluler &amp; Wi‑Fi"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Sinkronisasi otomatis data pribadi"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Sinkronisasi otomatis data kerja"</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Ubah daur..."</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Tanggal dalam bulan untuk menyetel ulang daur penggunaan data:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"Tak ada apl yg menggunakan data dlm periode ini."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Latar depan"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Latar belakang"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"terbatas"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Nonaktifkan kuota seluler?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Tetapkan batas data seluler"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Tetapkan batas data 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Tetapkan batas data 2G-3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Tetapkan batas data Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"Wi‑Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="2951873059375493878">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="952231704205870928">"Ponsel"</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">"Ponsel"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"Tidak ada"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Data seluler"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"Data 2G-3G"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"Data 4G"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Roaming"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"Latar depan:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"Latar belakang:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"Setelan aplikasi"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Data latar belakang"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Aktifkan penggunaan data seluler di latar belakang"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Untuk membatasi data latar belakang pada apl ini, setel batas data seluler terlebih dulu."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"Batasi data latar belakang?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"Fitur ini dapat menghentikan aplikasi yang bergantung pada data latar saat hanya ada jaringan seluler.\n\nAnda dapat menemukan kontrol penggunaan data yang lebih sesuai dalam setelan yang tersedia dalam aplikasi."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="8599940395497268584">"Pembatasan data latar belakang hanya dimungkinkan jika Anda telah menyetel batas data seluler."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"Aktifkan sinkronisasi data otomatis?"</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"Nonaktifkan sinkronisasi data otomatis?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"Hal ini akan menghemat penggunaan baterai dan data, tetapi Anda perlu menyinkronkan setiap akun secara manual untuk mengumpulkan informasi terkini. Anda juga tidak akan menerima notifikasi ketika ada pembaruan."</string>
    <string name="data_usage_cycle_editor_title" msgid="2019035830921480941">"Tanggal reset siklus penggunaan"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Tanggal setiap bulannya:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Setel"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Setel peringatan penggunaan data"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Setel batas penggunaan data"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Membatasi penggunaan data"</string>
    <string name="data_usage_sweep_warning" msgid="2072854703184614828"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font><font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"peringatan"</font></string>
    <string name="data_usage_sweep_limit" msgid="6947019190890086284"><font size="12">"batas"</font>\n<font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Aplikasi dihapus"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Aplikasi dan pengguna yang dihapus"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Penggunaan jaringan"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"Berbayar"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Nama"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Jenis"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Alamat server"</string>
    <string name="vpn_mppe" msgid="7366657055055114239">"Enkripsi PPP (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="2356744369959140121">"Rahasia L2TP"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"Pengenal IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"Kunci pra-bagi IPSec"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"Sertifikat pengguna IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"Sertifikat CA IPSec"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"Sertifikat server IPSec"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Tampilkan opsi lanjutan"</string>
    <string name="vpn_search_domains" msgid="1973799969613962440">"Domain penelusuran DNS"</string>
    <string name="vpn_dns_servers" msgid="6505263074417737107">"Server DNS (misal: 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="1218707725375594862">"Rute penerusan (misal: 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Nama pengguna"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Sandi"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Simpan informasi akun"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(tidak digunakan)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(jangan verifikasi server)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(diterima dari server)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="4699113710248872972">"Jenis VPN ini tidak dapat selalu terhubung"</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="2635347740046212693">"VPN selalu aktif hanya mendukung alamat server numerik"</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="3980357762395272467">"Server DNS untuk VPN selalu aktif harus ditentukan"</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3934369594591801587">"Alamat server DNS untuk VPN selalu aktif harus numerik"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"Informasi yang dimasukkan tidak mendukung VPN selalu aktif"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Batal"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Tutup"</string>
    <string name="vpn_save" msgid="683868204634860888">"Simpan"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Hubungkan"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Ganti"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"Edit profil VPN"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Lupakan"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Menghubungkan ke <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Putuskan sambungan VPN ini?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Putuskan koneksi"</string>
    <string name="vpn_version" msgid="6344167191984400976">"Versi"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Lupakan VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Ganti VPN yang sudah ada?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Setel VPN selalu aktif?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Jika setelan ini diaktifkan, koneksi internet hanya akan tersedia setelah VPN berhasil terhubung"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"VPN yang sudah ada akan digantikan, dan koneksi internet hanya akan tersedia setelah VPN berhasil terhubung"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Anda sudah terhubung ke VPN selalu aktif. Jika Anda terhubung ke VPN yang berbeda, VPN yang sudah ada akan digantikan, dan mode selalu aktif akan dinonaktifkan."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Anda sudah terhubung ke VPN. Jika Anda terhubung ke VPN yang berbeda, VPN yang sudah ada akan digantikan."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Aktifkan"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"<xliff:g id="VPN_NAME">%1$s</xliff:g> tidak dapat terhubung"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"Aplikasi ini tidak mendukung VPN yang selalu aktif"</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"Menambahkan profil VPN"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Edit profil"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Hapus profil"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"VPN selalu aktif"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Tidak ada VPN yang ditambahkan"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Selalu terhubung ke VPN"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Tidak didukung oleh aplikasi ini"</string>
    <string name="vpn_always_on_summary_active" msgid="175877594406330387">"Selalu aktif"</string>
    <string name="vpn_insecure_summary" msgid="4450920215186742859">"Tidak aman"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Memblokir koneksi tanpa VPN"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"Perlu sambungan VPN?"</string>
    <string name="vpn_insecure_dialog_subtitle" msgid="1857621742868835300">"Tidak aman. Update ke VPN IKEv2"</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Pilih profil VPN untuk tetap terhubung. Lalu lintas jaringan hanya akan diperbolehkan jika terhubung ke VPN ini."</string>
    <string name="vpn_lockdown_none" msgid="455915403560910517">"Tidak ada"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"VPN selalu aktif membutuhkan alamat IP baik untuk server serta DNS."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"Tidak ada koneksi jaringan. Coba lagi nanti."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Terputus dari VPN"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Tidak ada"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Sertifikat tidak ditemukan. Coba edit profil."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"Sistem"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Pengguna"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Nonaktifkan"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Aktifkan"</string>
    <string name="trusted_credentials_remove_label" msgid="8296330919329489422">"Uninstal"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Percayai"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"Aktifkan sertifikat CA sistem?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"Nonaktifkan sertifikat CA sistem?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"Hapus sertifikat CA pengguna secara permanen?"</string>
    <string name="credential_being_used_by" msgid="3682869943025283499">"Sedang digunakan oleh"</string>
    <string name="credential_contains" msgid="3146519680449595771">"Entri ini berisi"</string>
    <string name="one_userkey" msgid="6363426728683951234">"1 kunci pengguna"</string>
    <string name="one_usercrt" msgid="2097644070227688983">"1 sertifikat pengguna"</string>
    <string name="one_cacrt" msgid="982242103604501559">"1 Sertifikat CA"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"Sertifikat CA %d"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Detail kredensial"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Kredensial yang dihapus: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Kredensial pengguna tidak terinstal"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Pemeriksa ejaan"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Pemeriksa ejaan untuk kerja"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Ketikkan sandi cadangan penuh saat ini di sini"</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Ketik sandi baru untuk cadangan penuh di sini"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Ketik ulang sandi baru cadangan penuh Anda di sini"</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Setel sandi cadangan"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Batal"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Update sistem tambahan"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Jaringan mungkin dipantau"</string>
    <string name="done_button" msgid="6269449526248267">"Selesai"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="1032088078702042090">"{count,plural, =1{Percayai atau hapus sertifikat}other{Percayai atau hapus sertifikat}}"</string>
    <string name="ssl_ca_cert_info_message_device_owner" msgid="7528581447864707873">"{numberOfCertificates,plural, =1{{orgName} telah menginstal certificate authority di perangkat Anda, yang dapat memungkinkan mereka memantau aktivitas jaringan perangkat, termasuk email, aplikasi, dan situs aman.\n\nUntuk informasi selengkapnya tentang sertifikat ini, hubungi admin.}other{{orgName} telah menginstal certificate authority di perangkat Anda, yang dapat memungkinkan mereka memantau aktivitas jaringan perangkat, termasuk email, aplikasi, dan situs aman.\n\nUntuk informasi selengkapnya tentang sertifikat ini, hubungi admin.}}"</string>
    <string name="ssl_ca_cert_info_message" msgid="3111724430981667845">"{numberOfCertificates,plural, =1{{orgName} telah menginstal certificate authority untuk profil kerja Anda, yang dapat memungkinkan mereka memantau aktivitas jaringan kerja, termasuk email, aplikasi, dan situs aman.\n\nUntuk informasi selengkapnya tentang sertifikat ini, hubungi admin.}other{{orgName} telah menginstal certificate authority untuk profil kerja Anda, yang dapat memungkinkan mereka memantau aktivitas jaringan kerja, termasuk email, aplikasi, dan situs aman.\n\nUntuk informasi selengkapnya tentang sertifikat ini, hubungi admin.}}"</string>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"Pihak ketiga dapat memantau aktivitas jaringan Anda, termasuk email, aplikasi, dan situs web aman.\n\nKredensial terpercaya yang dipasang pada perangkat Anda memungkinkan hal ini."</string>
    <string name="ssl_ca_cert_settings_button" msgid="2044927302268394991">"{count,plural, =1{Periksa sertifikat}other{Periksa sertifikat}}"</string>
    <string name="user_settings_title" msgid="6550866465409807877">"Multi-pengguna"</string>
    <string name="user_list_title" msgid="1387379079186123404">"Pengguna &amp; profil"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Tambahkan pengguna atau profil"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Profil dibatasi"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Tidak disiapkan"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Tidak disiapkan - Profil dibatasi"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Tidak disiapkan - Profil kerja"</string>
    <string name="user_admin" msgid="4024553191395768119">"Admin"</string>
    <string name="user_you" msgid="3070562015202859996">"Anda (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="3328539978480663740">"Tidak dapat menambahkan pengguna lagi. Hapus satu pengguna untuk menambahkan pengguna baru."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Profil yang dibatasi tidak dapat menambahkan akun"</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Hapus <xliff:g id="USER_NAME">%1$s</xliff:g> di perangkat"</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Setelan layar kunci"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Tambahkan pengguna dari layar kunci"</string>
    <string name="switch_to_dock_user_when_docked" msgid="2324395443311905635">"Beralih ke pengguna admin saat terpasang ke dok"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Hapus diri Anda sendiri?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Hapus pengguna ini?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Buang profil ini?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Hapus profil kerja?"</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Semua aplikasi dan data akan dihapus."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"Semua aplikasi dan data dalam profil ini akan dihapus jika Anda melanjutkan."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Semua aplikasi dan data akan dihapus."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Menambahkan pengguna baru..."</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Hapus pengguna"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Hapus"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Semua aplikasi dan data dalam sesi ini akan dihapus."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Hapus"</string>
    <string name="guest_category_title" msgid="5562663588315329152">"Tamu (Anda)"</string>
    <string name="user_category_title" msgid="4368580529662699083">"Pengguna"</string>
    <string name="other_user_category_title" msgid="7089976887307643217">"Pengguna lainnya"</string>
    <string name="remove_guest_on_exit" msgid="8202972371459611066">"Hapus aktivitas tamu"</string>
    <string name="remove_guest_on_exit_summary" msgid="3969962695703280353">"Hapus semua aplikasi dan data tamu saat keluar dari mode tamu"</string>
    <string name="remove_guest_on_exit_dialog_title" msgid="2310442892536079416">"Hapus aktivitas tamu?"</string>
    <string name="remove_guest_on_exit_dialog_message" msgid="8112409834021851883">"Aplikasi dan data dari sesi tamu ini akan dihapus sekarang, dan semua aktivitas tamu mendatang akan dihapus setiap kali Anda keluar dari mode tamu"</string>
    <string name="remove_guest_on_exit_keywords" msgid="4961310523576166193">"hapus, tamu, aktivitas, buang, data, pengunjung"</string>
    <string name="enable_guest_calling" msgid="8300355036005240911">"Izinkan tamu menggunakan ponsel"</string>
    <string name="enable_guest_calling_summary" msgid="4748224917641204782">"Histori panggilan akan dibagikan kepada pengguna tamu"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Aktifkan panggilan telepon &amp; SMS"</string>
    <string name="user_grant_admin" msgid="5942118263054572074">"Jadikan pengguna ini sebagai admin"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Hapus pengguna"</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Aktifkan panggilan telepon &amp; SMS?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"Histori panggilan dan SMS akan dibagikan kepada pengguna ini."</string>
    <string name="user_revoke_admin_confirm_title" msgid="3057842401861731863">"Hapus hak istimewa admin?"</string>
    <string name="user_revoke_admin_confirm_message" msgid="9207187319308572958">"Jika Anda menghapus hak istimewa admin dari pengguna ini, Anda atau admin lain dapat memberikannya kembali di lain waktu."</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Informasi darurat"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Info &amp; kontak untuk <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="open_app_button" msgid="5025229765547191710">"Buka <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Izinkan aplikasi dan konten"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Aplikasi dengan batasan"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Luaskan setelan untuk aplikasi"</string>
    <string name="user_choose_copy_apps_to_another_user" msgid="5914037067347012870">"Pilih aplikasi yang akan diinstal"</string>
    <string name="user_copy_apps_menu_title" msgid="5354300105759670300">"Instal aplikasi yang tersedia"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Pembayaran nirsentuh"</string>
    <string name="nfc_default_payment_settings_title" msgid="2150504446774382261">"Aplikasi pembayaran default"</string>
    <string name="nfc_default_payment_footer" msgid="978535088340021360">"Untuk membayar dengan aplikasi pembayaran, dekatkan bagian belakang perangkat ke terminal pembayaran"</string>
    <string name="nfc_more_details" msgid="1700713533074275233">"Pelajari lebih lanjut"</string>
    <string name="nfc_default_payment_workapp_confirmation_title" msgid="746921251872504687">"Setel aplikasi kerja sebagai aplikasi pembayaran default?"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_title" msgid="1533022606333010329">"Untuk membayar dengan aplikasi kerja:"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_1" msgid="2917430119080702912">"profil kerja harus diaktifkan."</string>
    <string name="nfc_default_payment_workapp_confirmation_message_2" msgid="8161184137833245628">"Anda perlu memasukkan PIN, pola, atau sandi profil kerja, jika ada."</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Cara kerjanya"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Bayar dengan ponsel di toko"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"Pembayaran default"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Belum disetel"</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">"Gunakan aplikasi pembayaran default"</string>
    <string name="nfc_payment_use_default_dialog" msgid="8556328090777785383">"Gunakan aplikasi pembayaran default"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Selalu"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"Kecuali jika aplikasi pembayaran lain dibuka"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"Di terminal nirsentuh, bayar dengan:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Membayar di terminal"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Siapkan aplikasi pembayaran. Lalu, cukup dekatkan bagian belakang ponsel ke terminal mana saja yang memiliki simbol nirsentuh."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"Mengerti"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Lainnya …"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Setel aplikasi pembayaran default"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Update aplikasi pembayaran default"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"Di terminal nirsentuh, bayar dengan <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"Di terminal tanpa kontak kartu fisik, bayar dengan <xliff:g id="APP_0">%1$s</xliff:g>.\n\nIni menggantikan <xliff:g id="APP_1">%2$s</xliff:g> sebagai aplikasi pembayaran default."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Jadikan default"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Perbarui"</string>
    <string name="nfc_work_text" msgid="2496515165821504077">"Kerja"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Batasan"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Hapus batasan"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Ubah PIN"</string>
    <string name="help_label" msgid="2896538416436125883">"Bantuan &amp; masukan"</string>
    <string name="user_account_title" msgid="6389636876210834864">"Akun untuk konten"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"ID Foto"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Ancaman ekstrem"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Terima peringatan untuk ancaman genting bagi harta dan nyawa"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Ancaman berat"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Terima peringatan untuk ancaman berat bagi harta dan nyawa"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"Notifikasi AMBER"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Terima buletin tentang penculikan anak"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Ulangi"</string>
    <string name="call_manager_enable_title" msgid="1214301265395158720">"Aktifkan Pengelola Panggilan"</string>
    <string name="call_manager_enable_summary" msgid="7362506369604163030">"Memungkinkan layanan ini mengelola cara panggilan Anda dilakukan."</string>
    <string name="call_manager_title" msgid="3397433159509629466">"Pengelola Telepon"</string>
    <!-- no translation found for call_manager_summary (2558839230880919191) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Peringatan darurat nirkabel"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Penyedia jaringan"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Nama poin akses"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Advanced Calling"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"Panggilan 4G"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1067066329756036427">"Gunakan layanan LTE untuk meningkatkan kualitas panggilan suara (direkomendasikan)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="2575004054914178405">"Gunakan layanan 4G untuk meningkatkan kualitas panggilan suara (direkomendasikan)"</string>
    <string name="nr_advanced_calling_title" msgid="6106286679535355939">"Vo5G"</string>
    <string name="nr_advanced_calling_summary" msgid="6926192539172030330">"Gunakan 5G untuk panggilan suara"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Kirimkan kontak ke operator"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Kirim nomor telepon kontak untuk menyediakan fitur yang disempurnakan"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Kirimkan kontak ke <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"Kirimkan kontak ke operator?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Nomor telepon kontak akan dikirimkan secara berkala ke <xliff:g id="CARRIER">%1$s</xliff:g>.<xliff:g id="EMPTY_LINE">

</xliff:g>Info ini mengidentifikasi apakah kontak dapat menggunakan fitur tertentu, seperti panggilan video atau beberapa fitur pengiriman pesan."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"Nomor telepon kontak akan dikirimkan secara berkala ke operator.<xliff:g id="EMPTY_LINE">

</xliff:g>Info ini mengidentifikasi apakah kontak dapat menggunakan fitur tertentu, seperti panggilan video atau beberapa fitur pengiriman pesan."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Preferensi jenis jaringan"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (disarankan)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"Pesan MMS"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Kirim &amp; terima saat data seluler nonaktif"</string>
    <string name="auto_data_switch_title" msgid="5862200603753603464">"Beralih ke data seluler secara otomatis"</string>
    <string name="auto_data_switch_summary" msgid="1934340931995429057">"Gunakan jaringan ini saat ketersediaannya lebih baik"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"SIM yang Bekerja"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Akses konten &amp; aplikasi"</string>
    <string name="user_rename" msgid="8735940847878484249">"GANTI NAMA"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Setel batasan aplikasi"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Dikontrol oleh <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Aplikasi ini dapat mengakses akun Anda"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"Aplikasi ini dapat mengakses akun. Dikontrol oleh <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="2630656989926554685">"Wi‑Fi dan Seluler"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Memungkinkan modifikasi setelan Wi‑Fi dan Seluler"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Memungkinkan modifikasi setelan dan penyandingan Bluetooth"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Lokasi"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Memungkinkan aplikasi menggunakan informasi lokasi Anda"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Kembali"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Berikutnya"</string>
    <string name="wizard_back_adoptable" msgid="1447814356855134183">"Format dengan cara lain"</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 seluler tidak tersedia"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Ketuk untuk memilih SIM data"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Selalu gunakan ini untuk telepon"</string>
    <string name="select_sim_for_data" msgid="2642305487659432499">"Pilih SIM untuk data seluler"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Pilih SIM untuk SMS"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Mengalihkan SIM data, mungkin perlu waktu beberapa saat …"</string>
    <string name="select_specific_sim_for_data_title" msgid="5851980301321577985">"Gunakan <xliff:g id="NEW_SIM">%1$s</xliff:g> untuk data seluler?"</string>
    <string name="select_specific_sim_for_data_msg" msgid="7401698123430573637">"Jika Anda beralih ke <xliff:g id="NEW_SIM">%1$s</xliff:g>, <xliff:g id="OLD_SIM">%2$s</xliff:g> tidak akan digunakan lagi untuk data seluler."</string>
    <string name="select_specific_sim_for_data_button" msgid="6571935548920603512">"Gunakan <xliff:g id="NEW_SIM">%1$s</xliff:g>"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Telepon dengan"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Masukkan nama SIM"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"Slot SIM %1$d"</string>
    <string name="color_orange" msgid="216547825489739010">"Oranye"</string>
    <string name="color_purple" msgid="6603701972079904843">"Ungu"</string>
    <string name="sim_status_title" msgid="6188770698037109774">"Status SIM"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"Status SIM (slot sim %1$d)"</string>
    <string name="sim_signal_strength" msgid="6351052821700294501">"<xliff:g id="DBM">%1$d</xliff:g> dBm <xliff:g id="ASU">%2$d</xliff:g> asu"</string>
    <string name="sim_notification_title" msgid="2819551384383504031">"SIM diubah."</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Ketuk untuk menyiapkan"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Selalu tanya"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Perlu dipilih"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"pilihan SIM"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Setelan"</string>
    <string name="network_dashboard_title" msgid="788543070557731240">"Jaringan dan internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="7750924671970583670">"Data seluler, Wi‑Fi, hotspot"</string>
    <string name="network_dashboard_summary_no_mobile" msgid="4022575916334910790">"Wi‑Fi, hotspot"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Perangkat terhubung"</string>
    <string name="connected_devices_dashboard_default_summary" msgid="7211769956193710397">"Bluetooth, penyambungan"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, mode mengemudi, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, mode mengemudi"</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, mode mengemudi, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, mode mengemudi"</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">"Tidak tersedia karena NFC nonaktif"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Untuk menggunakannya, instal aplikasi pembayaran terlebih dahulu"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Aplikasi baru-baru ini, aplikasi default"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Akses notifikasi tidak tersedia untuk aplikasi di profil kerja"</string>
    <string name="account_dashboard_title" msgid="8228773251948253914">"Sandi &amp; akun"</string>
    <string name="account_dashboard_default_summary" msgid="1730719656099599488">"Sandi tersimpan, isi otomatis, akun yang disinkronkan"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Aplikasi default"</string>
    <string name="cloned_apps_dashboard_title" msgid="5542076801222950921">"Aplikasi Clone"</string>
    <string name="desc_cloned_apps_intro_text" msgid="1369621522882622476">"Buat instance aplikasi kedua agar Anda dapat menggunakan dua akun bersamaan."</string>
    <string name="desc_cloneable_app_list_text" msgid="3354586725814708688">"Aplikasi yang dapat di-clone."</string>
    <string name="cloned_apps_summary" msgid="8805362440770795709">"<xliff:g id="CLONED_APPS_COUNT">%1$s</xliff:g> di-clone, <xliff:g id="ALLOWED_APPS_COUNT">%2$d</xliff:g> dapat di-clone"</string>
    <string name="delete_all_app_clones" msgid="3489053361980624999">"Hapus semua Clone aplikasi"</string>
    <string name="delete_all_app_clones_failure" msgid="6821033414547132335">"Gagal menghapus semua Clone aplikasi"</string>
    <string name="cloned_app_creation_summary" msgid="4642627294993918502">"Membuat…"</string>
    <string name="cloned_app_created_summary" msgid="7277912971544890710">"Di-clone"</string>
    <string name="cloned_app_creation_toast_summary" msgid="3854494347144867870">"Membuat clone <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="cloned_app_created_toast_summary" msgid="755225403495544163">"Clone <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> telah dibuat"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Bahasa, gestur, waktu, pencadangan"</string>
    <string name="languages_setting_summary" msgid="7963053736715746726">"Bahasa sistem, bahasa aplikasi, ucapan"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, wi-fi, koneksi jaringan, internet, nirkabel, data, wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"Notifikasi Wi‑Fi, notifikasi wi‑fi"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"penggunaan data"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Gunakan format 24 jam"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Buka dengan"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Aplikasi"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"zona waktu"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Chat head, sistem, notifikasi, jendela, dialog, tampilan, di atas aplikasi lain, tarik"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Senter, Lampu, Flash"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"wifi, wi-fi, beralih, kontrol"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"seluler, mobile, operator sel, nirkabel, data, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"wifi, wi-fi, telepon, menelepon"</string>
    <string name="keywords_display" msgid="874738809280751745">"layar, layar sentuh"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"layar redup, layar sentuh, baterai, terang"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"layar redup, malam, tint, shift malam, kecerahan, warna layar, warna, warni"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"latar belakang, personalisasi, sesuaikan tampilan"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"ukuran teks"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"proyeksikan, transmisikan, Pencerminan layar, Berbagi layar, pencerminan, bagikan layar, transmisi layar"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"ruang, disk, hard drive, penggunaan perangkat"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"penggunaan daya, isi daya"</string>
    <string name="keywords_battery_usage" msgid="1763573071014260220">"tampilkan penggunaan baterai, penggunaan baterai, penggunaan daya"</string>
    <string name="keywords_battery_saver" msgid="6289682844453234359">"penghemat baterai, penghemat daya, penghemat"</string>
    <string name="keywords_battery_adaptive_preferences" msgid="1774870663426502938">"preferensi adaptif, baterai adaptif"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"ejaan, kamus, periksaejaan, koreksi-otomatis"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"pengenal, masukan, ucapan, ucapkan, bahasa, handsfree, hands free, pengenalan, menyinggung, kata, audio, histori, bluetooth headset"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"beri rating, bahasa, default, ucapkan, berbicara, text to speech, aksesibilitas, pembaca layar, tunanetra"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"jam, militer"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"reset, memulihkan, pabrik"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"hapus total, hapus, pulihkan, kosongkan, hilangkan, reset ke setelan pabrik"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"printer"</string>
    <string name="keywords_sounds" msgid="187191900698371911">"bip speaker, speaker, volume, bisukan, senyapkan, audio, musik, sentuhan, getaran, getar"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"jangan jangan ganggu, mengganggu, gangguan, putus"</string>
    <string name="keywords_app" msgid="7983814237980258061">"RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"di sekitar, lokasi, histori, pelaporan, GPS"</string>
    <string name="keywords_accounts" msgid="3013897982630845506">"akun, tambahkan akun, profil kerja, tambah akun, buang, hapus"</string>
    <string name="keywords_users" msgid="3497517660077620843">"pembatasan, membatasi, dibatasi"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"koreksi teks, benar suara, getar otomatis, bahasa, isyarat, sarankan, saran, tema, menyinggung, kata, jenis, emoji, internasional"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"reset, preferensi, default"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"apl download aplikasi sistem"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"aplikasi, izin, keamanan"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"aplikasi, default"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"abaikan, pengoptimalan, istirahatkan, aplikasi siaga"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"terang, RGB, SRGB, warna, alami, standar"</string>
    <string name="keywords_screen_resolution" msgid="6652125115386722875">"FHD, QHD, resolusi, 1080p, 1440p"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"warna, suhu, D65, D73 putih, kuning, biru, hangat, sejuk"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"geser untuk membuka kunci, sandi, pola, PIN"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"sematkan ke layar"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"tantangan kerja, kerja, profil"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"profil kerja, profil yang dikelola, menyatukan, penyatuan, kerja, profil"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"gestur"</string>
    <string name="keywords_wallet" msgid="3757421969956996972">"wallet"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"bayar, tempel, pembayaran"</string>
    <string name="keywords_backup" msgid="707735920706667685">"backup, back up"</string>
    <string name="keywords_assist_gesture_launch" msgid="7710762655355161924">"gestur"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"wajah, buka kunci, autentikasi, login"</string>
    <string name="keywords_biometric_unlock" msgid="8569545388717753692">"wajah, buka kunci, autentikasi, login, sidik jari, biometrik"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, min, versi prl, imei sv"</string>
    <string name="keywords_sim_status" msgid="4221401945956122228">"jaringan, status jaringan seluler, status layanan, kekuatan sinyal, jenis jaringan seluler, roaming"</string>
    <string name="keywords_sim_status_esim" msgid="3338719238556853609">"jaringan, status jaringan seluler, status layanan, kekuatan sinyal, jenis jaringan seluler, roaming, eid"</string>
    <string name="keywords_sim_status_iccid" msgid="4775398796251969759">"jaringan, status jaringan seluler, status layanan, kekuatan sinyal, jenis jaringan seluler, roaming, iccid"</string>
    <string name="keywords_sim_status_iccid_esim" msgid="4634015619840979184">"jaringan, status jaringan seluler, status layanan, kekuatan sinyal, jenis jaringan seluler, roaming, iccid, eid"</string>
    <string name="keywords_esim_eid" msgid="8128175058237372457">"eid"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"nomor seri, versi hardware"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"level patch keamanan android, versi pita basis, versi kernel"</string>
    <string name="keywords_dark_ui_mode" msgid="6373999418195344014">"tema, terang, gelap, mode, sensitivitas cahaya, fotofobia, buat lebih gelap, gelapkan, mode gelap, migrain"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"tema gelap"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"bug"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Tampilan standby, tampilan Layar kunci"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"notifikasi layar kunci, notifikasi"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"wajah"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"sidik jari, tambahkan sidik jari"</string>
    <string name="keywords_biometric_settings" msgid="2173605297939326549">"wajah, sidik jari, tambahkan sidik jari"</string>
    <string name="keywords_active_unlock_settings" msgid="4511320720304388889">"buka dengan smartwatch, tambahkan buka dengan smartwatch"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"layar redup, layar sentuh, baterai, kecerahan smart, kecerahan dinamis, Kecerahan otomatis"</string>
    <string name="keywords_display_adaptive_sleep" msgid="4905300860114643966">"smart, layar redup, tidur, baterai, waktu tunggu, perhatian, tampilan, layar, tidak aktif"</string>
    <string name="keywords_auto_rotate" msgid="7288697525101837071">"kamera, smart, putar otomatis, putar-otomatis, putar, balik, rotasi, potret, lanskap, orientasi, vertikal, horizontal"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"upgrade, android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"dnd, jadwal, notifikasi, blokir, matikan suara, getar, tidur, kerja, fokus, suara, nonaktifkan notifkasi, hari, hari kerja, akhir pekan, malam hari, acara"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"layar, waktu kunci, waktu tunggu, layar kunci"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"memori, cache, data, hapus, kosongkan, kosong, ruang penyimpanan"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"terhubung, perangkat, headphone, headset, speaker, nirkabel, sambungkan, earbud, musik, media"</string>
    <string name="keywords_wallpaper" msgid="7332890404629446192">"latar belakang, tema, petak, sesuaikan, personalisasi"</string>
    <string name="keywords_styles" msgid="3367789885254807447">"ikon, aksen, warna, layar utama, layar kunci, pintasan, ukuran jam"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"default, asisten"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"pembayaran, default"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"notifikasi masuk"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"tethering usb, tethering bluetooth, hotspot wi-fi"</string>
    <string name="keywords_accessibility_vibration_primary_switch" msgid="730692154347231253">"sentuhan, getar, getaran"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"sentuhan, getar, layar, sensitivitas"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"sentuhan, getar, ponsel, panggilan, sensitivitas, dering"</string>
    <string name="keywords_ramping_ringer_vibration" msgid="3678966746742257366">"sentuhan, getar, ponsel, panggilan, dering, bertahap"</string>
    <string name="keywords_notification_vibration" msgid="2620799301276142183">"sentuhan, getar, sensitivitas, notifikasi"</string>
    <string name="keywords_alarm_vibration" msgid="4833220371621521817">"sentuhan, getar, sensitivitas, alarm"</string>
    <string name="keywords_media_vibration" msgid="723896490102792327">"sentuhan, getar, sensitivitas, media"</string>
    <string name="keywords_vibration" msgid="670455132028025952">"sentuhan, getar, getaran"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"penghemat baterai, sticky, tetap, penghemat daya, baterai"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"rutinitas, jadwal, penghemat baterai, penghemat daya, baterai, otomatis, persen"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"volte, panggilan telepon lanjutan, panggilan telepon 4g"</string>
    <string name="keywords_nr_advanced_calling" msgid="4157823099610141014">"vo5g, vonr, panggilan telepon lanjutan, panggilan telepon 5g"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"tambahkan bahasa, tambahkan sebuah bahasa"</string>
    <string name="keywords_font_size" msgid="1643198841815006447">"ukuran teks, hasil cetak besar, font besar, teks besar, gangguan penglihatan, buat teks lebih besar, pembesar font, pembesaran font"</string>
    <string name="keywords_always_show_time_info" msgid="1066752498285497595">"tampilan standby selalu aktif, AOD"</string>
    <string name="keywords_change_nfc_tag_apps_state" msgid="9032287964590554366">"nfc, tag, pembaca"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Volume, getar, Jangan Ganggu"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Volume media"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Volume transmisi"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Volume panggilan"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Volume alarm"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Volume dering &amp; notifikasi"</string>
    <string name="separate_ring_volume_option_title" msgid="2212910223857375951">"Volume dering"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Volume notifikasi"</string>
    <string name="ringer_content_description_silent_mode" msgid="1442257660889685934">"Pendering senyap"</string>
    <string name="ringer_content_description_vibrate_mode" msgid="5946432791951870480">"Pendering bergetar"</string>
    <string name="notification_volume_content_description_vibrate_mode" msgid="6097212000507408288">"Volume notifikasi dibisukan, perangkat akan bergetar saat menerima notifikasi"</string>
    <string name="volume_content_description_silent_mode" msgid="377680514551405754">"<xliff:g id="VOLUME_TYPE">%1$s</xliff:g> dibisukan"</string>
    <string name="notification_volume_disabled_summary" msgid="8679988555852056079">"Tidak tersedia karena volume dering dibisukan"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Nada dering ponsel"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Suara notifikasi default"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Suara yang diberikan aplikasi"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Suara notifikasi default"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Suara alarm default"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Getar lalu dering bertahap"</string>
    <string name="spatial_audio_title" msgid="6591051622375191603">"Audio spasial"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Nada tombol nomor"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Suara penguncian layar"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Getaran &amp; suara pengisian daya"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Suara saat ditaruh di dok"</string>
    <string name="touch_sounds_title" msgid="826964355109667449">"Suara ketuk &amp; klik"</string>
    <string name="vibrate_icon_title" msgid="1281100105045362530">"Selalu tampilkan ikon saat dalam mode getar"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Dok pemutaran speaker"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Semua audio"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Hanya audio media"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Diam"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Nada"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Getaran"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Aktifkan suara"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Teks Otomatis"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Otomatis tambahkan teks ke media"</string>
    <string name="spatial_audio_speaker" msgid="9145233652433523302">"Speaker ponsel"</string>
    <string name="spatial_audio_wired_headphones" msgid="2237355789145828648">"Headphone berkabel"</string>
    <string name="spatial_audio_text" msgid="8201387855375146000">"Audio dari perangkat media yang kompatibel menjadi lebih imersif"</string>
    <string name="spatial_summary_off" msgid="8272678804629774378">"Nonaktif"</string>
    <string name="spatial_summary_on_one" msgid="6239933399496282994">"Aktif/<xliff:g id="OUTPUT_DEVICE">%1$s</xliff:g>"</string>
    <string name="spatial_summary_on_two" msgid="4526919818832483883">"On/<xliff:g id="OUTPUT_DEVICE_0">%1$s</xliff:g> dan <xliff:g id="OUTPUT_DEVICE_1">%2$s</xliff:g>"</string>
    <string name="spatial_audio_footer_title" msgid="8775010547623606088">"Anda juga dapat mengaktifkan Audio Spasial untuk perangkat Bluetooth."</string>
    <string name="spatial_audio_footer_learn_more_text" msgid="3826811708094366301">"Setelan perangkat terhubung"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Tidak ada}=1{1 jadwal disetel}other{# jadwal disetel}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Jangan Ganggu"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Hanya dapatkan notifikasi dari aplikasi dan orang yang penting"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Batasi gangguan"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Aktifkan mode Jangan Ganggu"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Alarm dan media boleh menginterupsi"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Jadwal"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Hapus jadwal"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Hapus"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Edit"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Jadwal"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Jadwal"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Jadwal"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Nonaktifkan notifikasi ponsel pada waktu tertentu"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Setel aturan Jangan Ganggu"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Jadwal"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Gunakan jadwal"</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">"Izinkan gangguan yang mengeluarkan suara"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Blokir gangguan visual"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Izinkan sinyal visual"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Opsi tampilan untuk notifikasi tersembunyi"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Saat mode Jangan Ganggu diaktifkan"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Tidak ada suara dari notifikasi"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Anda akan melihat notifikasi pada layar"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"Jika ada notifikasi, ponsel tidak akan mengeluarkan suara atau bergetar."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Tidak ada visual atau suara dari notifikasi"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Anda tidak akan melihat atau mendengar notifikasi"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="3761837271201073330">"Ponsel Anda tidak akan menampilkan, bergetar, atau bersuara jika ada notifikasi baik baru maupun lama. Perhatikan bahwa notifikasi yang penting untuk status dan aktivitas perangkat akan tetap muncul.\n\nKetika Anda menonaktifkan Jangan Ganggu, temukan notifikasi yang terlewat dengan menggeser ke bawah dari bagian atas layar."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="5469078057954463796">"Kustom"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Aktifkan setelan kustom"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Hapus setelan kustom"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Tidak ada suara dari notifikasi"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Sebagian tersembunyi"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Tidak ada visual atau suara dari notifikasi"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Pembatasan kustom"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Saat layar aktif"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Saat layar nonaktif"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Nonaktifkan suara dan getaran"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Jangan nyalakan layar"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Jangan mengedipkan lampu"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Jangan munculkan notifikasi di layar"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Sembunyikan ikon status bar di bagian atas layar"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Sembunyikan titik notifikasi di ikon aplikasi"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Jangan aktifkan jika ada notifikasi"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Sembunyikan dari menu notifikasi"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Tidak pernah"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Saat layar nonaktif"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Saat layar aktif"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Suara dan getaran"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Tanda notifikasi suara, getaran, dan beberapa visual"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Tanda notifikasi suara, getaran, dan visual"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="6403365663466620328">"Notifikasi yang diperlukan untuk aktivitas dasar dan status perangkat tidak akan pernah disembunyikan."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Tidak ada"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"opsi lain"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Tambahkan"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Aktifkan"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Aktifkan sekarang"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Nonaktifkan sekarang"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"Mode Jangan Ganggu aktif hingga <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"Mode Jangan Ganggu akan tetap aktif hingga Anda menonaktifkannya"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"Mode Jangan Ganggu otomatis diaktifkan oleh jadwal (<xliff:g id="RULE_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"Mode Jangan Ganggu otomatis diaktifkan oleh aplikasi <xliff:g id="APP_NAME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"Mode Jangan Ganggu diaktifkan untuk <xliff:g id="RULE_NAMES">%s</xliff:g> dengan setelan kustom."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="8255159194653341835">" "<annotation id="link">"Lihat setelan kustom"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Hanya untuk prioritas"</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">"Aktif / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"Aktif"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Selalu tanya"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Sampai Anda menonaktifkannya"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{1 jam}other{# jam}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{1 menit}other{# menit}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Nonaktif}=1{Nonaktif / 1 jadwal dapat aktif otomatis}other{Nonaktif / # jadwal dapat aktif otomatis}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Yang boleh menginterupsi saat Jangan Ganggu aktif"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Orang"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Aplikasi"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Alarm &amp; gangguan lainnya"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Jadwal"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Durasi untuk Setelan Cepat"</string>
    <string name="zen_settings_general" msgid="2704932194620124153">"Umum"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Jika mode Jangan Ganggu diaktifkan, suara dan getaran akan dimatikan, kecuali untuk item yang Anda izinkan di atas."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Setelan kustom"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Tinjau jadwal"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"Oke"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Notifikasi"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Durasi"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Pesan, acara &amp; pengingat"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"Jika mode Jangan Ganggu diaktifkan, pesan, pengingat, dan acara akan dimatikan suara dan getarannya, kecuali item yang Anda izinkan di atas. Anda dapat menyesuaikan setelan pesan untuk mengizinkan teman, keluarga, atau kontak lain menghubungi Anda."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Selesai"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Setelan"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Tidak ada visual atau suara dari notifikasi"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Tidak ada suara dari notifikasi"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"Anda tidak akan melihat atau mendengar notifikasi. Panggilan dari kontak berbintang dan penelepon berulang diizinkan."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(Setelan saat ini)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Ubah setelan notifikasi mode Jangan Ganggu?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Suara profil kerja"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Gunakan suara profil pribadi"</string>
    <string name="work_use_personal_sounds_summary" msgid="608061627969077231">"Gunakan suara yang sama dengan profil pribadi"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Nada dering telepon kerja"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Suara notifikasi kerja default"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Suara alarm kerja default"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Sama dengan profil pribadi"</string>
    <string name="work_sync_dialog_title" msgid="7810248132303515469">"Gunakan suara profil pribadi?"</string>
    <string name="work_sync_dialog_yes" msgid="5785488304957707534">"Konfirmasi"</string>
    <string name="work_sync_dialog_message" msgid="5066178064994040223">"Profil kerja akan menggunakan suara yang sama dengan profil pribadi"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Notifikasi"</string>
    <string name="notification_dashboard_summary" msgid="7530169251902320652">"Histori notifikasi, percakapan"</string>
    <string name="conversation_notifs_category" msgid="2549844862379963273">"Percakapan"</string>
    <string name="general_notification_header" msgid="3669031068980713359">"Kelola"</string>
    <string name="app_notification_field" msgid="3208079070539894909">"Notifikasi aplikasi"</string>
    <string name="app_notification_field_summary" msgid="5981393613897713471">"Mengontrol notifikasi dari setiap aplikasi"</string>
    <string name="advanced_section_header" msgid="6478709678084326738">"Umum"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Notifikasi kerja"</string>
    <string name="profile_section_header_for_advanced_privacy" msgid="8385775428904838579">"Profil kerja"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Prioritas notifikasi adaptif"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Otomatis setel notifikasi dengan prioritas yang lebih rendah ke Senyap"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Urutan notifikasi adaptif"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Otomatis mengurutkan notifikasi menurut relevansi"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Masukan notifikasi adaptif"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Menunjukkan penyesuaian yang dilakukan pada notifikasi dan menampilkan opsi untuk memberikan masukan ke sistem"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Reset prioritas notifikasi"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Reset setelan penting yang diubah pengguna dan izinkan asisten notifikasi diprioritaskan"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Saran tindakan dan balasan"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Otomatis menampilkan saran tindakan &amp; balasan"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Menampilkan notifikasi baru-baru ini dan yang ditunda"</string>
    <string name="notification_history" msgid="8663811361243456201">"Histori notifikasi"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Gunakan histori notifikasi"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"Histori notifikasi dinonaktifkan"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Aktifkan histori notifikasi untuk melihat notifikasi baru-baru ini dan notifikasi yang ditunda"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Tidak ada notifikasi terbaru"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Notifikasi terbaru dan yang ditunda akan muncul di sini"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"menampilkan setelan notifikasi"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"membuka notifikasi"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Izinkan penundaan notifikasi"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Titik notifikasi di ikon aplikasi"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Balon"</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Balon"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Tampilkan percakapan ini dalam balon"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Tampilkan ikon mengambang di atas aplikasi"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="1794193899792284007">"Aktifkan balon untuk perangkat?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"Mengaktifkan balon untuk aplikasi ini juga akan mengaktifkan balon untuk perangkat.\n\nIni memengaruhi aplikasi atau percakapan lain yang dikirimkan ke balon."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Aktifkan"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Batal"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Aktif / Percakapan dapat muncul sebagai ikon mengambang"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Izinkan aplikasi menampilkan balon"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Beberapa percakapan akan muncul sebagai ikon mengambang di atas aplikasi lain"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Semua percakapan dapat dijadikan balon"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Percakapan yang dipilih dapat dijadikan balon"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Tidak ada yang dapat dijadikan balon"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Percakapan"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Semua percakapan dapat ditampilkan dalam balon, kecuali"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Nonaktifkan balon untuk percakapan ini"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Aktifkan balon untuk percakapan ini"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Geser ke kanan untuk menutup, ke kiri untuk menampilkan menu"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Geser ke kiri untuk menutup, ke kanan untuk menampilkan menu"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Sembunyikan notifikasi senyap di status bar"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Cahaya kedip"</string>
    <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Privasi"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Lewati layar kunci"</string>
    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"Setelah membuka kunci, langsung buka layar yang terakhir digunakan. Notifikasi tidak akan muncul di layar kunci. Geser layar dari atas ke bawah untuk melihat notifikasi."</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Layar kunci, Layar kunci, Lewati, Abaikan"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Saat profil kerja dikunci"</string>
    <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Tampilkan hanya notifikasi baru di layar kunci"</string>
    <string name="unseen_notifs_lock_screen_summary" msgid="5996722793868021391">"Otomatis hapus notifikasi yang telah dilihat sebelumnya dari layar kunci"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Notifikasi di layar kunci"</string>
    <string name="lock_screen_notifs_show_all_summary" msgid="4226586018375762117">"Tampilkan percakapan, default, dan senyap"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Tampilkan percakapan, default, dan senyap"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Sembunyikan percakapan dan notifikasi senyap"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Jangan tampilkan notifikasi"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Notifikasi sensitif"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Tampilkan konten sensitif saat terkunci"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Notifikasi profil kerja yang sensitif"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Tampilkan konten profil kerja yang sensitif saat terkunci"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Tampilkan semua konten notifikasi"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Tampilkan konten sensitif hanya saat tidak terkunci"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Jangan tampilkan notifikasi sama sekali"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="4688399629301178487">"Bagaimana tampilan layar kunci yang Anda inginkan?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Layar kunci"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Tampilkan semua konten notifikasi profil kerja"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Sembunyikan konten kerja sensitif"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"Saat perangkat dikunci, Anda ingin notifikasi ditampilkan seperti apa?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Notifikasi profil"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Notifikasi"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Notifikasi aplikasi"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Kategori notifikasi"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Perilaku"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Percakapan"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Bagian percakapan"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Izinkan aplikasi untuk menggunakan bagian percakapan"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Bukan percakapan"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Hapus dari bagian percakapan"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"Ini adalah sebuah percakapan"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Menambahkan ke bagian percakapan"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"Tidak ada percakapan prioritas"</string>
    <string name="priority_conversation_count" msgid="7291234530844412077">"{count,plural, =1{# percakapan prioritas}other{# percakapan prioritas}}"</string>
    <string name="important_conversations" msgid="1233893707189659401">"Percakapan prioritas"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Muncul di bagian teratas percakapan dan ditampilkan sebagai balon mengambang"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Muncul di atas bagian percakapan"</string>
    <string name="other_conversations" msgid="551178916855139870">"Percakapan non-prioritas"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Percakapan yang telah Anda ubah"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Percakapan terbaru"</string>
    <string name="conversation_settings_clear_recents" msgid="8940398397663307054">"Hapus percakapan terbaru"</string>
    <string name="recent_convos_removed" msgid="2122932798895714203">"Percakapan terakhir dihapus"</string>
    <string name="recent_convo_removed" msgid="8686414146325958281">"Percakapan dihapus"</string>
    <string name="clear" msgid="5092178335409471100">"Hapus"</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Percakapan prioritas dan yang diubah akan muncul di sini"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Setelah Anda menandai percakapan sebagai prioritas, atau membuat perubahan lain pada percakapan, percakapan akan muncul di sini. \n\nUntuk mengubah setelan percakapan: \nGeser layar dari atas ke bawah untuk membuka menu notifikasi, lalu sentuh lama percakapan."</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Perkecil"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Munculkan di layar"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Senyap"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Default"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Izinkan notifikasi"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"Izinkan aplikasi bersuara, bergetar, dan/atau menampilkan notifikasi di layar"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Prioritas"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Muncul teratas di bagian percakapan, ditampilkan sebagai balon yang mengambang, menampilkan foto profil di layar kunci"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"<xliff:g id="APP_NAME">%1$s</xliff:g> tidak mendukung sebagian besar fitur percakapan. Anda tidak dapat menyetel percakapan sebagai prioritas, dan percakapan tidak akan ditampilkan sebagai balon yang mengambang."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"Di menu notifikasi, ciutkan notifikasi menjadi satu baris"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Tidak ada suara atau getaran"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"Tidak ada suara atau getaran dan ditampilkan lebih rendah di bagian percakapan"</string>
    <string name="notification_channel_summary_default" msgid="1168420867670390611">"Dapat berdering atau bergetar berdasarkan setelan perangkat"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Saat perangkat tidak terkunci, tampilkan notifikasi sebagai banner di bagian atas layar"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"Semua notifikasi \"<xliff:g id="APP_NAME">%1$s</xliff:g>\""</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Semua notifikasi <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="notifications_sent_daily" msgid="10274479224185437">"{count,plural, =1{Sekitar # notifikasi per hari}other{Sekitar # notifikasi per hari}}"</string>
    <string name="notifications_sent_weekly" msgid="7895656213187555346">"{count,plural, =1{Sekitar # notifikasi per minggu}other{Sekitar # notifikasi per minggu}}"</string>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Tidak pernah"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Notifikasi perangkat dan aplikasi"</string>
    <string name="manage_notification_access_summary" msgid="2907135226478903997">"Kontrol aplikasi dan perangkat mana yang dapat membaca notifikasi"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"Akses ke notifikasi profil kerja diblokir"</string>
    <string name="notification_assistant_title" msgid="5889201903272393099">"Notifikasi yang ditingkatkan"</string>
    <string name="notification_assistant_summary" msgid="1957783114840908887">"Dapatkan saran tindakan, balasan, dan lainnya"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Tidak ada"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Tidak ada aplikasi terpasang yang meminta akses notifikasi."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Izinkan akses notifikasi"</string>
    <string name="notification_assistant_security_warning_summary" msgid="4846559755787348129">"Notifikasi yang ditingkatkan menggantikan Notifikasi Adaptif Android di Android 12. Fitur ini menunjukkan tindakan dan balasan yang disarankan, serta mengatur notifikasi. \n\nNotifikasi yang ditingkatkan dapat mengakses konten notifikasi, termasuk informasi pribadi seperti nama kontak dan pesan. Fitur ini juga dapat menutup atau merespons notifikasi, seperti menjawab panggilan telepon dan mengontrol fitur Jangan Ganggu."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Izinkan akses notifikasi untuk <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1131986567509818121">"Aplikasi <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> akan dapat membaca semua notifikasi, termasuk informasi pribadi seperti nama kontak, foto kontak, dan teks pesan yang Anda terima. Aplikasi ini juga akan dapat menunda atau menutup notifikasi atau melakukan tindakan pada tombol di notifikasi, termasuk menjawab panggilan telepon. \n\nTindakan ini juga akan memberi aplikasi kemampuan untuk mengaktifkan atau menonaktifkan fitur Jangan Ganggu dan mengubah setelan terkait."</string>
    <string name="nls_warning_prompt" msgid="1486887096703743841">"Aplikasi <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> akan dapat:"</string>
    <string name="nls_feature_read_title" msgid="7629713268744220437">"Membaca notifikasi Anda"</string>
    <string name="nls_feature_read_summary" msgid="1064698238110273593">"Aplikasi dapat membaca notifikasi, termasuk informasi pribadi seperti kontak, pesan, dan foto."</string>
    <string name="nls_feature_reply_title" msgid="7925455553821362039">"Membalas pesan"</string>
    <string name="nls_feature_reply_summary" msgid="4492543411395565556">"Aplikasi dapat membalas pesan dan melakukan tindakan pada tombol di notifikasi, termasuk menunda atau menutup notifikasi dan menjawab panggilan."</string>
    <string name="nls_feature_settings_title" msgid="8208164329853194414">"Mengubah setelan"</string>
    <string name="nls_feature_settings_summary" msgid="3770028705648985689">"Aplikasi dapat mengaktifkan atau menonaktifkan fitur Jangan Ganggu dan mengubah setelan terkait."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Jika Anda menonaktifkan akses notifikasi untuk <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>, akses ke mode Jangan Ganggu mungkin juga akan dinonaktifkan."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Nonaktifkan"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Batalkan"</string>
    <string name="notif_type_ongoing" msgid="135675014223627555">"Real-time"</string>
    <string name="notif_type_ongoing_summary" msgid="2348867528527573574">"Komunikasi yang sedang berlangsung dari aplikasi yang sedang digunakan, navigasi, panggilan telepon, dan lainnya"</string>
    <string name="notif_type_conversation" msgid="4383931408641374979">"Percakapan"</string>
    <string name="notif_type_conversation_summary" msgid="179142405410217101">"SMS, pesan teks, dan komunikasi lainnya"</string>
    <string name="notif_type_alerting" msgid="4713073696855718576">"Notifikasi"</string>
    <string name="notif_type_alerting_summary" msgid="4681068287836313604">"Dapat berdering atau bergetar berdasarkan setelan"</string>
    <string name="notif_type_silent" msgid="6273951794420331010">"Senyap"</string>
    <string name="notif_type_silent_summary" msgid="7820923063105060844">"Notifikasi yang tidak pernah mengeluarkan suara atau getaran"</string>
    <string name="notification_listener_allowed" msgid="5536962633536318551">"Diizinkan"</string>
    <string name="notification_listener_not_allowed" msgid="3352962779597846538">"Tidak diizinkan"</string>
    <string name="notif_listener_excluded_app_title" msgid="6679316209330349730">"Lihat semua aplikasi"</string>
    <string name="notif_listener_excluded_app_summary" msgid="2914567678047195396">"Ubah setelan untuk setiap aplikasi yang mengirim notifikasi"</string>
    <string name="notif_listener_excluded_app_screen_title" msgid="8636196723227432994">"Aplikasi yang ditampilkan di perangkat"</string>
    <string name="notif_listener_not_migrated" msgid="6265206376374278226">"Aplikasi ini tidak mendukung setelan yang ditingkatkan"</string>
    <string name="notif_listener_more_settings" msgid="1348409392307208921">"Setelan lainnya"</string>
    <string name="notif_listener_more_settings_desc" msgid="7995492074281663658">"Setelan lainnya tersedia di dalam aplikasi ini"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"Layanan bantuan VR"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Tidak ada aplikasi terinstal yang meminta dijalankan sebagai layanan bantuan VR"</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"Izinkan akses layanan VR untuk <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> dapat dijalankan saat Anda sedang menggunakan aplikasi dalam mode virtual reality."</string>
    <string name="display_vr_pref_title" msgid="4850474436291113569">"Saat perangkat dalam mode VR"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Kurangi buram (disarankan)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Kurangi kedipan"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Picture-in-picture"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Tidak ada aplikasi terinstal yang mendukung Picture-in-picture"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"masukkan gambar"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Picture-in-picture"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Izinkan picture-in-picture"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Mengizinkan aplikasi ini membuat jendela picture-in-picture saat aplikasi terbuka atau setelah Anda membiarkannya terbuka (misalnya, untuk melanjutkan menonton video). Jendela ini ditampilkan di atas aplikasi lain yang sedang digunakan."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Aplikasi kerja &amp; pribadi yang terhubung"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Terhubung"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Tidak terhubung"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"Tidak ada aplikasi yang terhubung"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"antar-profil aplikasi terhubung aplikasi kerja dan pribadi"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Terhubung"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Hubungkan aplikasi ini"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Aplikasi yang terhubung memiliki izin yang sama dan dapat saling mengakses data masing-masing."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Hubungkan aplikasi hanya jika Anda percaya aplikasi tersebut tidak membagikan data pribadi kepada admin IT."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Anda dapat memutuskan hubungan aplikasi kapan saja di setelan privasi perangkat."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Percayai aplikasi <xliff:g id="NAME">%1$s</xliff:g> kerja untuk mengakses data pribadi Anda?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Hubungkan aplikasi hanya jika Anda percaya aplikasi tersebut tidak membagikan data pribadi kepada admin IT."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"Data aplikasi"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Aplikasi ini dapat mengakses data di aplikasi <xliff:g id="NAME">%1$s</xliff:g> pribadi Anda."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Izin"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Aplikasi ini dapat menggunakan izin aplikasi <xliff:g id="NAME">%1$s</xliff:g> pribadi Anda, seperti akses ke lokasi, penyimpanan, atau kontak."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Tidak ada aplikasi yang terhubung"</string>
    <string name="interact_across_profiles_number_of_connected_apps" msgid="4000424798291479207">"{count,plural, =1{# aplikasi terhubung}other{# aplikasi terhubung}}"</string>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Untuk menghubungkan aplikasi ini, instal <xliff:g id="NAME">%1$s</xliff:g> di profil kerja Anda"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Untuk menghubungkan aplikasi ini, instal <xliff:g id="NAME">%1$s</xliff:g> di profil pribadi Anda"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Ketuk untuk mendapatkan aplikasi"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Akses Jangan Ganggu"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Izinkan Mode Jangan Ganggu"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Tidak ada aplikasi terpasang yang meminta akses Jangan Ganggu"</string>
    <string name="app_notifications_off_desc" msgid="2484843759466874201">"Anda belum mengizinkan notifikasi dari aplikasi ini"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"Sesuai permintaan, Android memblokir kategori notifikasi ini agar tidak muncul di perangkat ini"</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"Sesuai permintaan, Android memblokir grup notifikasi ini agar tidak muncul di perangkat ini"</string>
    <string name="app_notifications_not_send_desc" msgid="5683060986735070528">"Aplikasi ini tidak mengirim notifikasi"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Kategori"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Lainnya"</string>
    <string name="no_channels" msgid="4716199078612071915">"Aplikasi ini belum memposting notifikasi"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Setelan tambahan di aplikasi"</string>
    <string name="deleted_channels" msgid="8489800381509312964">"{count,plural, =1{# kategori dihapus}other{# kategori dihapus}}"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Blokir semua"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Jangan pernah tampilkan notifikasi ini"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Tampilkan notifikasi"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Jangan pernah tampilkan notifikasi di bayangan atau di perangkat periferal"</string>
    <string name="app_notification_fsi_permission_title" msgid="5424116606034705020">"Izinkan notifikasi mode layar penuh"</string>
    <string name="app_notification_fsi_permission_summary" msgid="7673487977631068039">"Izinkan notifikasi ditampilkan dalam mode layar penuh ketika perangkat terkunci"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Izinkan titik notifikasi"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Tampilkan titik notifikasi"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Timpa mode Jangan Ganggu"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Tetap tampilkan notifikasi ini sekalipun mode Jangan Ganggu aktif"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Layar kunci"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Selesai"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Cahaya kedip"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Getaran"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Suara"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Prioritas"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Nama jadwal"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Masukkan nama jadwal"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"Nama jadwal sudah digunakan"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Tambahkan lainnya"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Tambahkan jadwal acara"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Tambahkan jadwal waktu"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Pilih jenis jadwal"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Hapus aturan \"<xliff:g id="RULE">%1$s</xliff:g>\"?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Hapus"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"Setelan ini tidak dapat diubah untuk saat ini. Aplikasi (<xliff:g id="APP_NAME">%1$s</xliff:g>) otomatis mengaktifkan Jangan Ganggu dengan perilaku kustom."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"Setelan ini tidak dapat diubah untuk saat ini. Aplikasi otomatis mengaktifkan Jangan Ganggu dengan perilaku kustom."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"Setelan ini tidak dapat diubah untuk saat ini. Jangan Ganggu diaktifkan secara manual dengan perilaku kustom."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Waktu"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Acara"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Selama acara untuk"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"Kalender mana saja"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"Jika balasannya adalah"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"Ya, Mungkin, atau Tidak dibalas"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"Ya atau Mungkin"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Ya"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Aturan tidak ditemukan."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"Aktif / <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">"Hari"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Tidak ada"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"Alarm dapat mengganti waktu berakhir"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Jadwal nonaktif saat alarm berdering"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Perilaku mode Jangan Ganggu"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Gunakan setelan default"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Buat setelan kustom untuk jadwal ini"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"Untuk ‘<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">"Percakapan"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"Semua percakapan"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Percakapan prioritas"</string>
    <string name="zen_mode_from_important_conversations_second" msgid="7588299891972136599">"percakapan prioritas"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Tidak ada"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Tidak ada}=1{1 percakapan}other{# percakapan}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Siapa yang boleh menginterupsi"</string>
    <string name="zen_mode_people_footer" msgid="7710707353004137431">"Meskipun aplikasi pesan atau telepon tidak dapat memberikan notifikasi, orang yang dipilih di sini tetap dapat menghubungi Anda melalui aplikasi tersebut"</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Panggilan telepon"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Panggilan telepon"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"panggilan telepon"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Panggilan telepon yang boleh menginterupsi"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"Agar panggilan yang diizinkan mengeluarkan suara, pastikan perangkat disetel untuk berdering"</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"Untuk ‘<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>’, panggilan masuk akan diblokir. Anda dapat menyesuaikan setelan untuk mengizinkan teman, keluarga, atau kontak lain menghubungi Anda."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Kontak berbintang"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Tidak ada}=1{{contact_1}}=2{{contact_1} dan {contact_2}}=3{{contact_1}, {contact_2}, dan {contact_3}}other{{contact_1}, {contact_2}, dan # lainnya}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Tanpa nama)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Pesan"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"pesan"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Pesan"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Pesan yang boleh menginterupsi"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"Agar notifikasi pesan yang diizinkan mengeluarkan suara, pastikan perangkat disetel untuk berdering"</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"Untuk ‘<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>’, pesan masuk akan diblokir. Anda dapat menyesuaikan setelan untuk mengizinkan teman, keluarga, atau kontak lain menghubungi Anda."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Semua pesan boleh masuk"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Semua panggilan boleh masuk"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Tidak ada}=1{1 kontak}other{# kontak}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Siapa saja"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Kontak"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Kontak berbintang"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Tidak ada"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Tidak ada"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Alarm"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"Dari timer, alarm, sistem keamanan, dan aplikasi lainnya"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"alarm"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Alarm"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Suara media"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Suara dari video, game, dan media lainnya"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"media"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Media"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Suara sentuhan"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Suara dari keyboard dan tombol lain"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"suara sentuhan"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Suara sentuhan"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Pengingat"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"Dari tugas dan pengingat"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"pengingat"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Pengingat"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Acara Kalender"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"Dari acara kalender mendatang"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"acara"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"Acara"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Izinkan aplikasi mengganti"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Aplikasi yang boleh menginterupsi"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Pilih aplikasi lainnya"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Tidak ada aplikasi yang dipilih"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Tidak ada aplikasi yang boleh menginterupsi"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Tambahkan aplikasi"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Semua notifikasi"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Beberapa notifikasi"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Orang yang dipilih tetap dapat menghubungi Anda meskipun aplikasi tidak diizinkan menginterupsi"</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Tidak ada aplikasi yang boleh menginterupsi}=1{{app_1} boleh menginterupsi}=2{{app_1} dan {app_2} boleh menginterupsi}=3{{app_1}, {app_2}, dan {app_3} boleh menginterupsi}other{{app_1}, {app_2}, dan # lainnya boleh menginterupsi}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Aplikasi"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Notifikasi yang boleh menginterupsi"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Izinkan semua notifikasi"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Tidak ada yang boleh menginterupsi}=1{{sound_category_1} boleh menginterupsi}=2{{sound_category_1} dan {sound_category_2} boleh menginterupsi}=3{{sound_category_1}, {sound_category_2}, dan {sound_category_3} boleh menginterupsi}other{{sound_category_1}, {sound_category_2}, dan # lainnya boleh menginterupsi}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Tidak ada yang boleh menginterupsi"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Tidak ada orang yang boleh menginterupsi"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Sebagian orang boleh menginterupsi"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Semua orang boleh menginterupsi"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Penelepon berulang"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Izinkan penelepon berulang"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"semua orang"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"kontak"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"kontak yang berbintang"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"penelepon berulang"</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> dan <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"Jika orang yang sama menelepon untuk kedua kalinya dalam waktu <xliff:g id="MINUTES">%d</xliff:g> menit"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Waktu mulai"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Waktu selesai"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> hari berikutnya"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Ubah ke mode hanya alarm untuk waktu yang tidak ditentukan"</string>
    <string name="zen_mode_summary_alarms_only_by_minute" msgid="6673649005494939311">"{count,plural, =1{Ubah ke mode hanya alarm selama satu menit hingga {time}}other{Ubah ke mode hanya alarm selama # menit (hingga {time})}}"</string>
    <string name="zen_mode_summary_alarms_only_by_hour" msgid="7400910210950788163">"{count,plural, =1{Ubah ke mode hanya alarm selama satu jam hingga {time}}other{Ubah ke mode hanya alarm selama # jam hingga {time}}}"</string>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Ubah ke mode hanya alarm hingga <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Ubah ke mode selalu ganggu"</string>
    <string name="warning_button_text" msgid="1274234338874005639">"Peringatan"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Tutup"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Kirim masukan tentang perangkat ini"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Masukkan PIN admin"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"Aktif"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Nonaktif"</string>
    <string name="nfc_setting_on" msgid="7701896496026725772">"Aktif"</string>
    <string name="nfc_setting_off" msgid="7142103438532732309">"Nonaktif"</string>
    <string name="screen_pinning_switch_on_text" msgid="6971386830247542552">"Aktif"</string>
    <string name="screen_pinning_switch_off_text" msgid="5032105155623003875">"Nonaktif"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Penyematan aplikasi"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"Penyematan aplikasi memungkinkan Anda terus menampilkan aplikasi saat ini hingga sematannya dilepas. Fitur ini dapat digunakan, misalnya, untuk mengizinkan teman tepercaya bermain game tertentu."</string>
    <string name="screen_pinning_description" msgid="4305370471370474846">"Saat aplikasi disematkan, aplikasi tersebut mungkin dapat membuka aplikasi lain dan data pribadi mungkin dapat diakses. \n\nUntuk menggunakan penyematan aplikasi: 	\n1. Aktifkan penyematan aplikasi 	\n2. Buka Ringkasan 	\n3. Ketuk ikon aplikasi di bagian atas layar, lalu ketuk Sematkan"</string>
    <string name="screen_pinning_guest_user_description" msgid="2465729370037556955">"Saat aplikasi disematkan, aplikasi tersebut mungkin dapat membuka aplikasi lain dan data pribadi mungkin dapat diakses. \n\nJika Anda ingin perangkat digunakan orang lain dengan aman, coba gunakan pengguna tamu. \n\nUntuk menggunakan penyematan aplikasi: 	\n1. Aktifkan penyematan aplikasi 	\n2. Buka Ringkasan \n3. Ketuk ikon aplikasi di bagian atas layar, lalu ketuk Sematkan"</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Saat aplikasi disematkan: \n\n•	 Data pribadi mungkin dapat diakses \n		(seperti kontak dan konten email) \n•	 Aplikasi yang disematkan mungkin dapat membuka aplikasi lain \n\nGunakan penyematan aplikasi hanya untuk orang yang Anda percayai."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Minta pola pembuka kunci sebelum melepas sematan"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Minta PIN sebelum melepas sematan"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Minta sandi sebelum melepas sematan"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Kunci perangkat saat melepas sematan"</string>
    <string name="confirm_sim_deletion_title" msgid="9199369003530237871">"Konfirmasi penghapusan SIM"</string>
    <string name="confirm_sim_deletion_description" msgid="4439657901673639063">"Verifikasi diri Anda sebelum menghapus eSIM"</string>
    <string name="memtag_title" msgid="5096176296797727201">"Proteksi memori lanjutan beta"</string>
    <string name="memtag_toggle" msgid="8695028758462939212">"Perlindungan memori lanjutan"</string>
    <string name="memtag_intro" msgid="579408691329568953">"Fitur beta ini membantu Anda melindungi perangkat dari bug yang dapat membahayakan keamanan."</string>
    <string name="memtag_on" msgid="824938319141503923">"Aktif"</string>
    <string name="memtag_off" msgid="4835589640091709019">"Nonaktif"</string>
    <string name="memtag_on_pending" msgid="1592053425431532361">"Aktif setelah mulai ulang"</string>
    <string name="memtag_off_pending" msgid="1543177181383593726">"Nonaktif setelah mulai ulang"</string>
    <string name="memtag_force_off" msgid="1143468955988138470">"Tidak tersedia untuk perangkat Anda"</string>
    <string name="memtag_force_on" msgid="3254349938627883664">"Selalu aktif untuk perangkat Anda"</string>
    <string name="memtag_footer" msgid="8480784485124271376">"Anda harus memulai ulang perangkat untuk mengaktifkan atau menonaktifkan Perlindungan memori lanjutan. Saat aktif, Anda mungkin akan mengalami performa perangkat yang lebih lambat."</string>
    <string name="memtag_reboot_title" msgid="1413471876903578769">"Mulai ulang perangkat?"</string>
    <string name="memtag_reboot_message_on" msgid="3270256606602439418">"Anda harus memulai ulang perangkat untuk mengaktifkan Perlindungan memori lanjutan."</string>
    <string name="memtag_reboot_message_off" msgid="2567062468140476451">"Anda harus memulai ulang perangkat untuk menonaktifkan Perlindungan memori lanjutan."</string>
    <string name="memtag_reboot_yes" msgid="5788896350697141429">"Mulai ulang"</string>
    <string name="memtag_reboot_no" msgid="2860671356184849330">"Lain kali"</string>
    <string name="memtag_learn_more" msgid="1596145970669119776">"Pelajari lebih lanjut Perlindungan memori lanjutan."</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"Profil kerja ini dikelola oleh:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Dikelola oleh <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Buka secara default"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Buka link yang didukung"</string>
    <string name="app_launch_top_intro_message" msgid="137370923637482459">"Izinkan link web untuk dibuka di aplikasi ini"</string>
    <string name="app_launch_links_category" msgid="2380467163878760037">"Link yang dapat dibuka di aplikasi ini"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Link yang didukung"</string>
    <string name="app_launch_other_defaults_title" msgid="5674385877838735586">"Preferensi default lainnya"</string>
    <string name="app_launch_add_link" msgid="8622558044530305811">"Tambahkan link"</string>
    <string name="app_launch_footer" msgid="4521865035105622557">"Aplikasi dapat memverifikasi link agar otomatis terbuka di aplikasi."</string>
    <string name="app_launch_verified_links_title" msgid="621908751569155356">"{count,plural, =1{# link terverifikasi}other{# link terverifikasi}}"</string>
    <string name="app_launch_verified_links_message" msgid="190871133877476176">"{count,plural, =1{Link ini terverifikasi dan terbuka di aplikasi ini secara otomatis.}other{Link ini terverifikasi dan terbuka di aplikasi ini secara otomatis.}}"</string>
    <string name="app_launch_dialog_ok" msgid="1446157681861409861">"Oke"</string>
    <string name="app_launch_verified_links_info_description" msgid="7514750232467132117">"Tampilkan daftar link terverifikasi"</string>
    <string name="app_launch_checking_links_title" msgid="6119228853554114201">"Memeriksa link lain yang didukung…"</string>
    <string name="app_launch_dialog_cancel" msgid="6961071841814898663">"Batal"</string>
    <string name="app_launch_supported_links_title" msgid="2457931321701095763">"{count,plural, =1{# link yang didukung}other{# link yang didukung}}"</string>
    <string name="app_launch_supported_links_add" msgid="3271247750388016131">"Tambahkan"</string>
    <string name="app_launch_supported_links_subtext" msgid="4268004019469184113">"Buka di <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"<xliff:g id="SIZE">%1$s</xliff:g> digunakan di <xliff:g id="STORAGE_TYPE">%2$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="979243131665635278">"penyimpanan internal"</string>
    <string name="storage_type_external" msgid="125078274000280821">"penyimpanan eksternal"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"<xliff:g id="SIZE">%1$s</xliff:g> digunakan sejak <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="2591194906751432725">"Penyimpanan yang terpakai"</string>
    <string name="change" msgid="273206077375322595">"Ganti"</string>
    <string name="change_storage" msgid="8773820275624113401">"Ganti penyimpanan"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Notifikasi"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"Aktif"</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">"Nonaktif"</string>
    <string name="notifications_categories_off" msgid="7712037485557237328">"{count,plural, =1{# kategori dinonaktifkan}other{# kategori dinonaktifkan}}"</string>
    <string name="runtime_permissions_additional_count" msgid="6071909675951786523">"{count,plural, =1{# izin tambahan}other{# izin tambahan}}"</string>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"Tidak ada izin yang diberikan"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Tidak ada izin yang diminta"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Kontrol akses aplikasi ke data Anda"</string>
    <string name="permissions_usage_title" msgid="2942741460679049132">"Dasbor privasi"</string>
    <string name="permissions_usage_summary" msgid="6784310472062516454">"Tampilkan aplikasi yang baru-baru ini menggunakan izin"</string>
    <string name="unused_apps" msgid="4566272194756830656">"Aplikasi yang tidak digunakan"</string>
    <string name="unused_apps_summary" msgid="4236371818881973021">"{count,plural, =1{# aplikasi tidak digunakan}other{# aplikasi tidak digunakan}}"</string>
    <string name="unused_apps_category" msgid="8954930958175500851">"Setelan aplikasi yang tidak digunakan"</string>
    <string name="unused_apps_switch" msgid="7595419855882245772">"Jeda aktivitas aplikasi jika tak dipakai"</string>
    <string name="unused_apps_switch_summary" msgid="2171098908014596802">"Hapus izin dan file sementara, serta hentikan notifikasi"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Semua aplikasi"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Aplikasi terinstal"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Aplikasi instan"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Dinonaktifkan"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Lanjutan"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Pengelola izin"</string>
    <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"Pembaruan berbagi data untuk lokasi"</string>
    <string name="app_data_sharing_updates_summary" msgid="4465929918457739443">"Tinjau aplikasi yang mengubah caranya berbagi data lokasi Anda"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Ketuk untuk membangunkan"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Ketuk layar dua kali di mana saja untuk membangunkan perangkat"</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Membuka link"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Jangan buka link yang didukung"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Buka <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Buka <xliff:g id="DOMAIN">%s</xliff:g> dan URL lain"</string>
    <string name="app_link_open_always" msgid="9167065494930657503">"Izinkan aplikasi membuka link yang didukung"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Selalu tanya"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Jangan izinkan aplikasi membuka link"</string>
    <string name="app_link_open_always_summary" msgid="4524005594295855117">"{count,plural, =1{Aplikasi mengklaim untuk menangani # link}other{Aplikasi mengklaim untuk menangani # link}}"</string>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"Aplikasi mengklaim untuk menangani link berikut:"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Bantuan &amp; masukan suara"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"Aplikasi asisten digital"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"Aplikasi asisten digital default"</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Setuju"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Aplikasi browser"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Aplikasi telepon"</string>
    <string name="system_app" msgid="1863291702508355041">"(Sistem)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Penyimpanan aplikasi"</string>
    <string name="usage_access" msgid="5487993885373893282">"Akses penggunaan"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Izinkan akses penggunaan"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Waktu pemakaian perangkat"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"Akses penggunaan memungkinkan aplikasi melacak aplikasi lain yang Anda gunakan serta seberapa sering penggunaannya, dan juga operator Anda, setelan bahasa, dan detail lainnya."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Memori"</string>
    <string name="always_running" msgid="9012705720688200252">"Selalu dijalankan (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Sesekali dijalankan (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Jarang dijalankan (<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">"Pengoptimalan baterai"</string>
    <string name="high_power_filter_on" msgid="447849271630431531">"Tidak dioptimalkan"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Tidak dioptimalkan"</string>
    <string name="high_power_off" msgid="317000444619279018">"Mengoptimalkan penggunaan baterai"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Pengoptimalan baterai tidak tersedia"</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Izinkan aplikasi selalu berjalan di latar belakang?"</string>
    <string name="high_power_prompt_body" msgid="6029266540782139941">"Mengizinkan <xliff:g id="APP_NAME">%1$s</xliff:g> selalu berjalan di latar belakang dapat mengurangi masa pakai baterai. \n\nAnda dapat mengubahnya nanti dari Setelan &gt; Aplikasi."</string>
    <string name="battery_summary" msgid="2491764359695671207">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> digunakan sejak terakhir kali baterai terisi penuh"</string>
    <string name="battery_summary_24hr" msgid="7656033283282656551">"Penggunaan <xliff:g id="PERCENTAGE">%1$s</xliff:g> dalam 24 jam terakhir"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Tidak ada penggunaan baterai sejak terakhir kali terisi penuh"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Bagikan laporan bug?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"Admin IT meminta laporan bug untuk membantu memecahkan masalah perangkat ini. Aplikasi dan data mungkin dibagikan."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"Admin IT meminta laporan bug untuk membantu memecahkan masalah perangkat ini. Aplikasi dan data mungkin dibagikan, dan untuk sementara perangkat mungkin menjadi lambat."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"Laporan bug ini sedang dibagikan kepada admin IT. Hubungi mereka untuk detail selengkapnya."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Bagikan"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Tolak"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Jangan transfer data"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Isi daya perangkat yang terhubung"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Transfer File"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"PTP"</string>
    <string name="usb_use_uvc_webcam" msgid="6595429508472038732">"Webcam"</string>
    <string name="usb_transcode_files" msgid="2441954752105119109">"Konversi video ke AVC"</string>
    <string name="usb_transcode_files_summary" msgid="307102635711961513">"Video akan diputar di beberapa pemutar media, tetapi kualitasnya mungkin berkurang"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"Tethering USB"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"Gunakan USB untuk"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Konfigurasi USB default"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Ketika perangkat lain terhubung dan ponsel Anda terbuka kuncinya, setelan ini akan berlaku. Hanya hubungkan ke perangkat tepercaya."</string>
    <string name="usb_power_title" msgid="5602112548385798646">"Opsi daya"</string>
    <string name="usb_file_transfer_title" msgid="2261577861371481478">"Opsi transfer file"</string>
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"Preferensi USB"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"USB dikontrol oleh"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Perangkat yang terhubung"</string>
    <string name="usb_control_device" msgid="527916783743021577">"Perangkat ini"</string>
    <string name="usb_switching" msgid="3654709188596609354">"Mengalihkan …"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"Tidak dapat beralih"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Sedang mengisi daya perangkat ini"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Mengisi daya perangkat yang terhubung"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Transfer file"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"Tethering USB"</string>
    <string name="usb_summary_photo_transfers" msgid="7331503733435780492">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2372443732675899571">"MIDI"</string>
    <string name="usb_summary_UVC" msgid="8733131110899174299">"Webcam"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Transfer file dan daya penyuplai"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"Tethering USB dan daya penyuplai"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP dan daya penyuplai"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"MIDI dan daya penyuplai"</string>
    <string name="usb_summary_UVC_power" msgid="226810354412154061">"Webcam dan menyuplai daya"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Pemeriksaan latar belakang"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Gunakan teks dari layar"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Izinkan aplikasi bantuan mengakses konten layar sebagai teks"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Gunakan screenshot"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Izinkan aplikasi bantuan mengakses gambar layar"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Kedipkan layar"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Kedipkan tepi layar saat aplikasi bantuan mengakses teks dari layar atau screenshot"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Aplikasi bantuan dapat membantu Anda berdasarkan informasi dari layar yang sedang Anda lihat. Beberapa aplikasi mendukung peluncur dan layanan masukan suara untuk memberikan bantuan terintegrasi."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Rata-rata penggunaan memori"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Penggunaan memori maksimum"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Penggunaan memori"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Penggunaan aplikasi"</string>
    <string name="memory_details" msgid="6133226869214421347">"Detail"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"<xliff:g id="SIZE">%1$s</xliff:g> rata-rata memori yang digunakan dalam 3 jam terakhir"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"Tidak ada memori yang digunakan dalam 3 jam terakhir"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Urutkan menurut rata-rata penggunaan"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Urutkan menurut penggunaan maksimum"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Performa"</string>
    <string name="total_memory" msgid="5244174393008910567">"Total memori"</string>
    <string name="average_used" msgid="690235917394070169">"Rata-rata digunakan (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Bebas"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Memori yang digunakan oleh aplikasi"</string>
    <string name="memory_usage_apps_summary" msgid="7168292864155527974">"{count,plural, =1{1 aplikasi menggunakan memori dalam {time} terakhir}other{# aplikasi menggunakan memori dalam {time} terakhir}}"</string>
    <string name="running_frequency" msgid="7260225121706316639">"Frekuensi"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Penggunaan maksimum"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Tidak ada data seluler yang digunakan"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"Izinkan akses ke status Jangan Ganggu untuk <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"Aplikasi akan dapat mengaktifkan/menonaktifkan status Jangan Ganggu dan mengubah setelan terkait."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Harus tetap aktif karena akses notifikasi juga aktif"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"Cabut akses ke status Jangan Ganggu untuk <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"Semua aturan Jangan Ganggu yang dibuat oleh aplikasi ini akan dihapus."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Jangan optimalkan"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Optimalkan"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Dapat menghabiskan baterai lebih cepat. Aplikasi tidak lagi dibatasi untuk menggunakan baterai di latar belakang."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Disarankan agar baterai lebih tahan lama"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Tidak ada"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Menonaktifkan akses penggunaan aplikasi ini tidak mencegah admin melacak penggunaan kuota aplikasi di profil kerja"</string>
    <string name="draw_overlay" msgid="7902083260500573027">"Tampilkan di atas apl lain"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Tampilkan di atas aplikasi lain"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Izinkan ditampilkan di atas aplikasi lain"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Mengizinkan aplikasi ini ditampilkan di atas aplikasi lain yang sedang digunakan. Aplikasi ini dapat melihat lokasi ketukan atau mengubah konten yang ditampilkan di layar."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Akses semua file"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Izinkan akses untuk mengelola semua file"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Mengizinkan aplikasi ini untuk membaca, mengubah, dan menghapus semua file di perangkat ini atau media penyimpanan yang terpasang. Jika diberikan, aplikasi dapat mengakses file tanpa sepengetahuan Anda."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Dapat mengakses semua file"</string>
    <string name="full_screen_intent_title" msgid="747270185715224130">"Notifikasi layar penuh"</string>
    <string name="permit_full_screen_intent" msgid="9035367640019960861">"Izinkan notifikasi layar penuh dari aplikasi ini"</string>
    <string name="footer_description_full_screen_intent" msgid="7716518411349225528">"Izinkan aplikasi ini menampilkan notifikasi dalam layar penuh ketika perangkat terkunci. Aplikasi mungkin menggunakan tindakan ini untuk memperjelas alarm, panggilan masuk, atau notifikasi penting lainnya."</string>
    <string name="media_management_apps_title" msgid="8222942355578724582">"Aplikasi pengelolaan media"</string>
    <string name="media_management_apps_toggle_label" msgid="166724270857067456">"Izinkan aplikasi untuk mengelola media"</string>
    <string name="media_management_apps_description" msgid="8000565658455268524">"Jika diizinkan, aplikasi ini dapat mengubah atau menghapus file media yang dibuat dengan aplikasi lain tanpa bertanya kepada Anda. Aplikasi harus memiliki izin untuk mengakses file dan media."</string>
    <string name="keywords_media_management_apps" msgid="7499959607583088690">"Media, File, Pengelolaan, Pengelola, Kelola, Edit, Editor, Apl, Aplikasi, Program"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"vr pemroses virtual reality stereo layanan bantuan"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Tampilkan di atas apl lain"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Aplikasi yang memiliki izin"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Diizinkan"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Tidak diizinkan"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"instal aplikasi dari sumber yang tidak dikenal"</string>
    <string name="write_settings" msgid="6864794401614425894">"Ubah setelan sistem"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"tulis ubah setelan sistem"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Dapat meng-install aplikasi lain"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Dapat mengubah setelan sistem"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Dapat mengubah setelan sistem"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Ubah setelan sistem"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Izinkan mengubah setelan sistem"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Izin ini memungkinkan aplikasi mengubah setelan sistem."</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Izinkan dari sumber ini"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Putar dua kali untuk kamera"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Membuka aplikasi kamera dengan memutar pergelangan tangan dua kali"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Ukuran tampilan"</string>
    <string name="screen_zoom_short_summary" msgid="756254364808639194">"Perbesar atau perkecil semuanya"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"layar, kepadatan, zoom layar, skala, penskalaan"</string>
    <string name="screen_zoom_preview_title" msgid="5288355628444562735">"Pratinjau"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Buat lebih kecil"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Buat lebih besar"</string>
    <string name="disconnected" msgid="3469373726996129247">"Tidak terhubung"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Tidak terhubung"</string>
    <string name="apps_summary" msgid="4007416751775414252">"<xliff:g id="COUNT">%1$d</xliff:g> aplikasi diinstal"</string>
    <string name="storage_summary" msgid="5903562203143572768">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> digunakan - <xliff:g id="FREE_SPACE">%2$s</xliff:g> kosong"</string>
    <string name="display_dashboard_summary" msgid="1599453894989339454">"Tema gelap, ukuran font, kecerahan"</string>
    <string name="memory_summary" msgid="8221954450951651735">"Rata-rata <xliff:g id="USED_MEMORY">%1$s</xliff:g> dari <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g> memori digunakan"</string>
    <string name="users_summary" msgid="8473589474976307510">"Login sebagai <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Telah diupdate ke Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"Ada update"</string>
    <string name="disabled_by_policy_title" msgid="6852347040813204503">"Diblokir oleh kebijakan kantor"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Volume tidak dapat diubah"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="400089720689494562">"Tidak dapat melakukan panggilan"</string>
    <string name="disabled_by_policy_title_sms" msgid="8951840850778406831">"Tidak dapat mengirim pesan SMS"</string>
    <string name="disabled_by_policy_title_camera" msgid="6616508876399613773">"Tidak dapat menggunakan kamera"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6085100101044105811">"Tidak dapat mengambil screenshot"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Aplikasi ini tidak dapat dibuka"</string>
    <string name="disabled_by_policy_title_financed_device" msgid="2328740314082888228">"Diblokir oleh penyedia kredit Anda"</string>
    <string name="disabled_by_policy_title_biometric_parental_consent" msgid="2463673997797134678">"Diperlukan izin orang tua"</string>
    <string name="disabled_by_policy_content_biometric_parental_consent" msgid="7124116806784305206">"Serahkan ponsel ke orang tua untuk mulai menyiapkannya"</string>
    <string name="disabled_by_policy_parental_consent" msgid="9166060049019018978">"Serahkan ponsel ke orang tua untuk mengizinkan setelan ini diubah."</string>
    <string name="default_admin_support_msg" msgid="8816296554831532033">"Untuk info lebih lanjut, hubungi admin IT Anda"</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Detail selengkapnya"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"Admin dapat memantau serta mengelola aplikasi dan data yang terkait dengan profil kerja, termasuk setelan, izin, akses perusahaan, aktivitas jaringan, dan informasi lokasi perangkat."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"Admin dapat memantau serta mengelola aplikasi dan data yang terkait dengan pengguna ini, termasuk setelan, izin, akses perusahaan, aktivitas jaringan, dan informasi lokasi perangkat."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"Admin dapat memantau serta mengelola aplikasi dan data yang terkait dengan perangkat ini, termasuk setelan, izin, akses perusahaan, aktivitas jaringan, dan informasi lokasi perangkat."</string>
    <string name="admin_financed_message" msgid="1156197630834947884">"Administrator perangkat Anda mungkin dapat mengakses data yang dikaitkan dengan perangkat ini, mengelola aplikasi, dan mengubah setelan perangkat ini."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Nonaktifkan"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Aktifkan"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Lihat"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Sembunyikan"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"Hotspot aktif"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Mode pesawat aktif"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Jaringan tidak tersedia"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"Mode Jangan Ganggu aktif"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Ponsel dimatikan suaranya"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"Dengan pengecualian"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Penghemat Baterai aktif"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Fitur dibatasi"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Kuota tidak aktif"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Internet hanya tersedia melalui Wi‑Fi"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Penghemat Data"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Fitur dibatasi"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Profil kerja nonaktif"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Untuk aplikasi &amp; notifikasi"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Aktifkan suara"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Pendering dimatikan suaranya"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Untuk panggilan telepon &amp; notifikasi"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Hanya getaran"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Untuk panggilan telepon &amp; notifikasi"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Setel jadwal Cahaya Malam"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Otomatis mewarnai layar setiap malam"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"Mode Cahaya Malam aktif"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Layar berona kuning"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Hitam putih"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Hanya menampilkan dalam hitam putih"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Ciutkan"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Suhu foto sejuk"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Gunakan suhu tampilan yang lebih sejuk"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Untuk menerapkan perubahan warna, nonaktifkan layar"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Sensor Laser Kamera"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Update sistem otomatis"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Terapkan update saat perangkat dimulai ulang"</string>
    <string name="usage" msgid="287782903846013936">"Penggunaan"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Penggunaan data seluler"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Penggunaan data oleh aplikasi"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"Penggunaan data Wi-Fi"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Penggunaan data nonoperator"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Penggunaan data ethernet"</string>
    <string name="wifi" msgid="2932584495223243842">"Wi-Fi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Ethernet"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"<xliff:g id="AMOUNT">^1</xliff:g> data seluler"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"<xliff:g id="AMOUNT">^1</xliff:g> data Wi-Fi"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"<xliff:g id="AMOUNT">^1</xliff:g> data ethernet"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Peringatan &amp; batas penggunaan data"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Siklus penggunaan data seluler"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"Peringatan penggunaan data <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"Batas kuota <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"Peringatan penggunaan data <xliff:g id="ID_1">^1</xliff:g> / Batas penggunaan data <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="operator_warning" msgid="5672761970087591211">"Perhitungan data oleh operator dapat berbeda dengan perhitungan perangkat"</string>
    <string name="non_carrier_data_usage_warning" msgid="4707184871368847697">"Mengecualikan data yang digunakan oleh jaringan operator"</string>
    <string name="data_used_template" msgid="8229342096562327646">"<xliff:g id="ID_1">%1$s</xliff:g> digunakan"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Setel peringatan penggunaan data"</string>
    <string name="data_warning" msgid="2925054658166062884">"Peringatan penggunaan data"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"Peringatan penggunaan dan batas data diukur oleh perangkat. Ini mungkin berbeda dengan perhitungan data operator."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Setel batas data"</string>
    <string name="data_limit" msgid="8731731657513652363">"Batas penggunaan data"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"<xliff:g id="ID_1">%1$s</xliff:g> digunakan <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="configure" msgid="1499586749829665889">"Konfigurasi"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Aplikasi lain yang disertakan dalam penggunaan"</string>
    <string name="data_saver_unrestricted_summary" msgid="7343571401172437542">"{count,plural, =1{1 aplikasi diizinkan untuk menggunakan data yang tidak dibatasi jika Penghemat Data aktif}other{# aplikasi diizinkan untuk menggunakan data yang tidak dibatasi jika Penghemat Data aktif}}"</string>
    <string name="data_usage_title" msgid="4039024073687469094">"Kuota utama"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"Data Wi-Fi"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"<xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g> digunakan"</string>
    <string name="data_overusage" msgid="3680477320458707259">"<xliff:g id="ID_1">^1</xliff:g> terlampaui"</string>
    <string name="data_remaining" msgid="6316251496381922837">"Tersisa <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Grafik yang menampilkan penggunaan data antara <xliff:g id="START_DATE">%1$s</xliff:g> dan <xliff:g id="END_DATE">%2$s</xliff:g>."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"Tidak ada data dalam rentang tanggal ini"</string>
    <string name="billing_cycle_days_left" msgid="174337287346866400">"{count,plural, =1{# hari lagi}other{# hari lagi}}"</string>
    <string name="billing_cycle_none_left" msgid="1694844019159277504">"Waktu habis"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Kurang dari 1 hari lagi"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"Diupdate oleh <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g> lalu"</string>
    <string name="no_carrier_update_text" msgid="5432798085593055966">"Diupdate <xliff:g id="ID_1">^2</xliff:g> lalu"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Diupdate oleh <xliff:g id="ID_1">^1</xliff:g> baru saja"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Baru saja diupdate"</string>
    <string name="launch_mdp_app_text" msgid="8791816789749304897">"Lihat paket"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Lihat detail"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Penghemat Data"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Data tidak dibatasi"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Data latar belakang nonaktif"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"Aktif"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Nonaktif"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Gunakan Penghemat Data"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Penggunaan data tidak dibatasi"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Izinkan akses data tanpa dibatasi saat Penghemat Data aktif"</string>
    <string name="home_app" msgid="6056850504746902747">"Aplikasi layar utama"</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Tambahkan sidik jari lain"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Buka kunci dengan jari lain"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"Aktif"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Akan aktif saat baterai <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Nonaktif"</string>
    <string name="app_battery_usage_title" msgid="346558380609793334">"Penggunaan baterai aplikasi"</string>
    <string name="app_battery_usage_summary" msgid="6349965904306339539">"Setel penggunaan baterai untuk aplikasi"</string>
    <string name="filter_battery_unrestricted_title" msgid="821027369424198223">"Tidak dibatasi"</string>
    <string name="filter_battery_optimized_title" msgid="8236647176487754796">"Dioptimalkan"</string>
    <string name="filter_battery_restricted_title" msgid="5886859505802563232">"Dibatasi"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Pemeriksa ejaan default"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Pilih pemeriksa ejaan"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Gunakan pemeriksa ejaan"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Tidak dipilih"</string>
    <string name="notification_log_details_delimiter" msgid="2475986465985309821">": "</string>
    <string name="notification_log_details_package" msgid="3205243985502010202">"pkt"</string>
    <string name="notification_log_details_key" msgid="2690467272328709046">"kunci"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"grup"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(ringkasan)"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"versiPublik"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"nilai penting"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"penjelasan"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"dapat menampilkan badge"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"maksud"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"hapus maksud"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"maksud layar penuh"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"tindakan"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"judul"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"masukan jarak jauh"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"tampilan khusus"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"tambahan"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"ikon"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"ukuran parsel"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"notifikasi diaktifkan"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"saluran"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Objek peringkat tidak ada."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"Objek peringkat tidak berisi kunci ini."</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Potongan layar"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"potongan tampilan, notch"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Default perangkat"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Gagal menerapkan overlay"</string>
    <string name="special_access" msgid="1767980727423395147">"Akses aplikasi khusus"</string>
    <plurals name="special_access_summary" formatted="false" msgid="4995506406763570815">
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aplikasi dapat menggunakan data tanpa dibatasi</item>
      <item quantity="one">1 aplikasi dapat menggunakan data tanpa dibatasi</item>
    </plurals>
    <string name="special_access_more" msgid="132919514147475846">"Lihat lainnya"</string>
    <string name="long_background_tasks_label" msgid="3169590134850226687">"Tugas latar belakang lama"</string>
    <string name="long_background_tasks_switch_title" msgid="2491623894899492543">"Izinkan tugas latar belakang yang berjalan lama"</string>
    <string name="long_background_tasks_title" msgid="3272230637974707490">"Tugas latar belakang lama"</string>
    <string name="long_background_tasks_footer_title" msgid="9117342254914743097">"Izinkan aplikasi ini melakukan tugas latar belakang yang berjalan lama. Tindakan ini memungkinkan aplikasi menjalankan tugas yang mungkin memerlukan waktu lebih dari beberapa menit untuk diselesaikan, seperti download dan upload. \n\nJika izin ini ditolak, sistem akan membatasi durasi aplikasi dapat melakukan tugas tersebut di latar belakang."</string>
    <string name="keywords_long_background_tasks" msgid="5788956269136054574">"tugas lama, transfer data, tugas latar belakang"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Reset pembatasan frekuensi ShortcutManager"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"Pembatasan kecepatan PengelolaPintasan telah direset"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Kontrol info di layar kunci"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Menampilkan atau menyembunyikan konten notifikasi"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Tips &amp; dukungan"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Lebar terkecil"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Tidak ada aplikasi yang terpasang yang meminta akses SMS Premium"</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"SMS Premium mungkin memerlukan biaya dan akan menambah tagihan operator. Jika izin aplikasi diaktifkan, Anda dapat mengirim SMS premium menggunakan aplikasi tersebut."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Akses SMS Premium"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Nonaktif"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Terhubung ke <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Terhubung ke beberapa perangkat"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Mode demo UI sistem"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Tema gelap"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Dinonaktifkan sementara karena fitur Penghemat Baterai"</string>
    <string name="ambient_camera_summary_battery_saver_on" msgid="1787784892047029560">"Dinonaktifkan sementara karena fitur Penghemat Baterai"</string>
    <string name="ambient_camera_battery_saver_off" msgid="689825730569761613">"Nonaktifkan penghemat baterai"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Diaktifkan sementara karena fitur Penghemat Baterai"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Coba Tema gelap"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Membantu menghemat baterai"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Kartu setelan cepat developer"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Nonaktifkan waktu tunggu otorisasi adb"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Nonaktifkan pencabutan otorisasi adb otomatis untuk sistem yang belum terhubung kembali dalam jangka waktu default (7 hari) atau yang dikonfigurasi oleh pengguna (minimal 1 hari)."</string>
    <string name="winscope_trace_quick_settings_title" msgid="4104768565053226689">"Pelacakan Winscope"</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Sensor Nonaktif"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Setelan profil kerja"</string>
    <string name="managed_profile_contact_search_title" msgid="6562061740814513737">"Telusuri kontak direktori kerja di aplikasi pribadi"</string>
    <string name="managed_profile_contact_search_summary" msgid="4974727886709219105">"Penelusuran dan panggilan masuk Anda mungkin dapat dilihat oleh admin IT"</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Kalender lintas profil"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Tampilkan aktivitas kerja di kalender pribadi Anda"</string>
    <string name="managed_profile_settings_footer" msgid="996500759305118103">"Saat aplikasi kerja dinonaktifkan, aplikasi akan dijeda dan tidak dapat diakses atau mengirimkan notifikasi"</string>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Kelola penyimpanan"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"Untuk membantu mengosongkan ruang penyimpanan, pengelola penyimpanan menghapus foto dan video cadangan dari perangkat Anda."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Hapus foto &amp; video"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Pengelola penyimpanan"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Gunakan Pengelola penyimpanan"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Gestur"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Buka kamera dengan cepat"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Untuk membuka kamera dengan cepat, tekan tombol daya dua kali. Berfungsi di layar mana pun."</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Balik kamera untuk selfie"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="system_navigation_title" msgid="4890381153527184636">"Mode navigasi"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Navigasi 2 tombol"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"Untuk beralih aplikasi, geser ke atas pada tombol Layar utama. Untuk melihat semua aplikasi, geser ke atas lagi. Untuk kembali, ketuk tombol kembali."</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Keselamatan &amp; keadaan darurat"</string>
    <string name="emergency_dashboard_summary" msgid="401033951074039302">"Darurat SOS, info medis, peringatan"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Navigasi gestur"</string>
    <string name="edge_to_edge_navigation_summary" msgid="8497033810637690561">"Untuk membuka Layar utama, geser layar dari bawah ke atas. Untuk beralih aplikasi, geser dari bawah ke atas, tahan, lalu lepas. Untuk kembali, geser dari tepi kiri atau kanan."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"Navigasi 3 tombol"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Anda dapat Kembali, membuka Layar utama, dan beralih aplikasi dengan tombol di bagian bawah layar."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"navigasi sistem, navigasi 2 tombol, navigasi 3 tombol, navigasi gestur, geser"</string>
    <string name="assistant_gesture_category_title" msgid="2478251256585807920">"Asisten digital"</string>
    <string name="assistant_corner_gesture_title" msgid="1895061522687002106">"Geser untuk memanggil asisten"</string>
    <string name="assistant_corner_gesture_summary" msgid="7279576276455168075">"Geser ke atas dari pojok bawah untuk memanggil aplikasi asisten digital."</string>
    <string name="assistant_long_press_home_gesture_title" msgid="4865972278738178753">"Tahan tombol Layar utama untuk membuka Asisten"</string>
    <string name="assistant_long_press_home_gesture_summary" msgid="592882226105081447">"Tekan dan tahan tombol Layar Utama untuk membuka aplikasi asisten digital."</string>
    <string name="low_label" msgid="6525629096999711220">"Rendah"</string>
    <string name="high_label" msgid="357503396626018487">"Tinggi"</string>
    <string name="left_edge" msgid="1513576842959071849">"Tepi kiri"</string>
    <string name="right_edge" msgid="1505309103265829121">"Tepi kanan"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"Sensitivitas yang lebih tinggi dapat memengaruhi fungsi gestur aplikasi di tepi layar."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Sensitivitas Bagian Belakang"</string>
    <string name="gesture_settings_activity_title" msgid="2025828425762595733">"Sensitivitas Navigasi Gestur"</string>
    <string name="button_navigation_settings_activity_title" msgid="7335636045504461813">"Navigasi tombol"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"navigasi gestur, sensitivitas kembali, gestur kembali"</string>
    <string name="keywords_button_navigation_settings" msgid="7888812253110553920">"navigasi, tombol layar utama"</string>
    <string name="one_handed_title" msgid="2584414010282746195">"Mode satu tangan"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Gunakan mode satu tangan"</string>
    <string name="one_handed_mode_shortcut_title" msgid="1847871530184067369">"Pintasan mode satu tangan"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"jangkauan"</string>
    <string name="one_handed_mode_swipe_down_category" msgid="110178629274462484">"Geser ke bawah untuk"</string>
    <string name="one_handed_mode_use_shortcut_category" msgid="1414714099339147711">"Gunakan pintasan untuk"</string>
    <string name="one_handed_mode_intro_text" msgid="7921988617828924342">"Tarik setengah layar bagian atas ke bawah agar lebih mudah dijangkau dengan satu tangan"</string>
    <string name="one_handed_mode_footer_text" msgid="6336209800330679840">" "<b>"Cara menggunakan mode satu tangan"</b>\n" • Pastikan navigasi gestur dipilih di setelan navigasi sistem\n • Geser ke bawah di dekat tepi bawah layar"</string>
    <string name="one_handed_action_pull_down_screen_title" msgid="9187194533815438150">"Menarik layar agar berada dalam jangkauan"</string>
    <string name="one_handed_action_pull_down_screen_summary" msgid="7582432473450036628">"Bagian atas layar akan dapat dijangkau ibu jari Anda."</string>
    <string name="one_handed_action_show_notification_title" msgid="8789305491485437130">"Menampilkan notifikasi"</string>
    <string name="one_handed_action_show_notification_summary" msgid="8281689861222000436">"Notifikasi dan setelan akan muncul."</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Untuk memeriksa waktu, notifikasi, dan info lainnya, ketuk dua kali layar Anda."</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Aktifkan tampilan"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Untuk memeriksa waktu, notifikasi, dan info lainnya, ketuk layar Anda."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"Darurat SOS"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7421353963329899514">"Gunakan Darurat SOS"</string>
    <string name="emergency_gesture_screen_summary" msgid="6640521030845132507">"Tekan tombol Daya dengan cepat 5 kali atau lebih untuk memulai tindakan di bawah ini"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Putar alarm hitung mundur"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="6573377104470235173">"Putar suara keras saat Darurat SOS dimulai"</string>
    <string name="emergency_gesture_category_call_for_help_title" msgid="1680040129478289510">"Minta bantuan"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Telepon bantuan"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Nomor untuk mendapatkan bantuan"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Ketuk untuk mengubah"</string>
    <string name="emergency_gesture_number_override_notes" msgid="233018570696200402">"Jika Anda memasukkan nomor non-darurat:\n • Perangkat harus dibuka kuncinya agar dapat menggunakan Darurat SOS\n • Panggilan Anda mungkin tidak dijawab"</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Usapkan sidik jari untuk melihat notifikasi"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Usapkan sidik jari"</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Melihat notifikasi dengan lebih cepat"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"Aktif"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Nonaktif"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"Bootloader telah dibuka kuncinya"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Hubungkan ke internet atau hubungi operator"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Tidak tersedia pada perangkat yang dikunci oleh operator"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Nyalakan ulang perangkat untuk mengaktifkan fitur perlindungan perangkat."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"<xliff:g id="SIZE">%1$s</xliff:g> total dibuat tersedia\n\nTerakhir dijalankan pada <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="6654581786741216382">"Aplikasi instan"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Buka link di aplikasi, meskipun jika tidak diinstal"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Aplikasi instan"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Preferensi Aplikasi Instan"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Aplikasi terinstal"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Penyimpanan kini dikelola oleh pengelola penyimpanan"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Akun untuk <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Sinkronisasi otomatis data aplikasi"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Izinkan aplikasi otomatis memuat ulang data"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Sinkronisasi akun"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Sinkronisasi aktif untuk <xliff:g id="ID_1">%1$d</xliff:g> dari <xliff:g id="ID_2">%2$d</xliff:g> item"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Sinkronisasi aktif untuk semua item"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Sinkronisasi nonaktif untuk semua item"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Info perangkat yang dikelola"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Perubahan &amp; setelan yang dikelola oleh organisasi"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Perubahan &amp; setelan yang dikelola oleh <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"Untuk menyediakan akses ke data kerja, organisasi mungkin mengubah setelan dan menginstal software di perangkat.\n\nUntuk info selengkapnya, hubungi admin organisasi."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Jenis informasi yang dapat dilihat organisasi"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Perubahan dibuat oleh admin organisasi"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Akses Anda ke perangkat ini"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Data yang terkait dengan akun kerja, seperti email dan kalender"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Daftar aplikasi di perangkat"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Jumlah waktu dan data yang dihabiskan di setiap aplikasi"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Log traffic jaringan terbaru"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Laporan bug terbaru"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Log keamanan terbaru"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Tidak ada"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Aplikasi diinstal"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"Jumlah aplikasi merupakan hasil perkiraan. Hal ini tidak menyertakan aplikasi yang diinstal selain dari Play Store."</string>
    <string name="enterprise_privacy_number_packages_lower_bound" msgid="5317634640873658149">"{count,plural, =1{Minimum # aplikasi}other{Minimum # aplikasi}}"</string>
    <string name="enterprise_privacy_location_access" msgid="8023838718108456971">"Izin akses lokasi"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Izin akses mikrofon"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Izin akses kamera"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Aplikasi default"</string>
    <string name="enterprise_privacy_number_packages" msgid="5294444005035188274">"{count,plural, =1{# aplikasi}other{# aplikasi}}"</string>
    <string name="enterprise_privacy_input_method" msgid="3278314982700662246">"Keyboard default"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Setel ke <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"VPN yang selalu aktif telah diaktifkan"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"VPN yang selalu aktif telah diaktifkan di profil pribadi"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"VPN yang selalu aktif telah diaktifkan di profil kerja"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Proxy HTTP global disetel"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Kredensial tepercaya"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Kredensial tepercaya di profil pribadi Anda"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Kredensial tepercaya di profil kerja Anda"</string>
    <string name="enterprise_privacy_number_ca_certs" msgid="4540897122831942658">"{count,plural, =1{Minimum # sertifikat CA}other{Minimum # sertifikat CA}}"</string>
    <string name="enterprise_privacy_lock_device" msgid="464054894363899866">"Admin dapat mengunci perangkat dan menyetel ulang sandi"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"Admin dapat menghapus semua data perangkat"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Kesalahan sandi sebelum menghapus semua data perangkat"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Kesalahan sandi sebelum menghapus data profil kerja"</string>
    <string name="enterprise_privacy_number_failed_password_wipe" msgid="2695842143305867642">"{count,plural, =1{# kali percobaan}other{# kali percobaan}}"</string>
    <string name="do_disclosure_generic" msgid="3067459392402324538">"Perangkat ini dikelola oleh organisasi."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"Perangkat ini dikelola oleh <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">"Pelajari lebih lanjut"</string>
    <string name="blocked_by_restricted_settings_title" msgid="7334715011474037399">"Setelan terbatas"</string>
    <string name="toast_allows_restricted_settings_successfully" msgid="1219116121291466102">"Setelan terbatas diizinkan untuk <xliff:g id="APP_NAME">%s</xliff:g>"</string>
    <string name="blocked_by_restricted_settings_content" msgid="3628660029601161080">"Demi keamanan Anda, setelan ini tidak tersedia untuk saat ini."</string>
    <string name="financed_privacy_settings" msgid="2575114436197204145">"Info perangkat yang dibiayai"</string>
    <string name="financed_privacy_intro" msgid="7836497475568741579">"Penyedia kredit Anda dapat mengubah setelan dan menginstal software di perangkat ini selama penyiapan.\n\nJika Anda terlambat membayar, penyedia kredit dapat mengunci perangkat dan mengubah setelan perangkat Anda.\n\nUntuk mempelajari lebih lanjut, hubungi penyedia kredit Anda."</string>
    <string name="financed_privacy_restrictions_category" msgid="2472659467919651602">"Saat perangkat dalam masa kredit, Anda tidak dapat:"</string>
    <string name="financed_privacy_install_apps" msgid="7381718005710210851">"Menginstal aplikasi, selain dari Play Store"</string>
    <string name="financed_privacy_safe_mode" msgid="5362149445732602578">"Memulai ulang perangkat ke mode aman"</string>
    <string name="financed_privacy_multi_users" msgid="1727194928477613081">"Menambahkan beberapa pengguna ke perangkat"</string>
    <string name="financed_privacy_config_date_time" msgid="8567370445374984365">"Mengubah tanggal, waktu, dan zona waktu"</string>
    <string name="financed_privacy_developer_options" msgid="7602001474669831672">"Menggunakan opsi developer"</string>
    <string name="financed_privacy_credit_provider_capabilities_category" msgid="8737902277892987998">"Penyedia kredit Anda dapat:"</string>
    <string name="financed_privacy_IMEI" msgid="1852413860963824799">"Mengakses nomor IMEI Anda"</string>
    <string name="financed_privacy_factory_reset" msgid="5505016667590160732">"Mereset perangkat ke setelan pabrik jika terjadi masalah"</string>
    <string name="financed_privacy_locked_mode_category" msgid="3708288398912647751">"Jika perangkat dikunci, Anda hanya dapat menggunakannya untuk:"</string>
    <string name="financed_privacy_emergency_calls" msgid="1108183987142736497">"Melakukan panggilan darurat"</string>
    <string name="financed_privacy_system_info" msgid="4158031444108708927">"Melihat info sistem seperti tanggal, waktu, status jaringan, dan baterai"</string>
    <string name="financed_privacy_turn_on_off_device" msgid="3331566753152790571">"Mengaktifkan atau menonaktifkan perangkat"</string>
    <string name="financed_privacy_notifications" msgid="5932303271274089968">"Melihat notifikasi &amp; SMS"</string>
    <string name="financed_privacy_allowlisted_apps" msgid="8333040812194879963">"Mengakses aplikasi yang diizinkan oleh penyedia kredit"</string>
    <string name="financed_privacy_fully_paid_category" msgid="9221763928564246923">"Setelah Anda melunasi pembayaran:"</string>
    <string name="financed_privacy_restrictions_removed" msgid="3182636815294595072">"Semua batasan dihapus dari perangkat"</string>
    <string name="financed_privacy_uninstall_creditor_app" msgid="6339004120497310705">"Anda dapat meng-uninstal aplikasi kreditur"</string>
    <string name="financed_device_info" msgid="3871860346697308342">"Info perangkat yang dibiayai"</string>
    <string name="default_camera_app_title" msgid="6546248868519965998">"{count,plural, =1{Aplikasi kamera}other{Aplikasi kamera}}"</string>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"aplikasi Kalender"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Aplikasi kontak"</string>
    <string name="default_email_app_title" msgid="5411280873093244250">"{count,plural, =1{Aplikasi program email}other{Aplikasi program email}}"</string>
    <string name="default_map_app_title" msgid="7569231732944853320">"Aplikasi peta"</string>
    <string name="default_phone_app_title" msgid="795025972645464135">"{count,plural, =1{Aplikasi telepon}other{Aplikasi telepon}}"</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">"Perangkat ini"</string>
    <string name="storage_games" msgid="1176568610086802469">"Game"</string>
    <string name="storage_files" msgid="7968460921272772299">"File"</string>
    <string name="storage_images" msgid="2055893015567979387">"Gambar"</string>
    <string name="storage_videos" msgid="6117698226447251033">"Video"</string>
    <string name="storage_audio" msgid="5994664984472140386">"Audio"</string>
    <string name="storage_apps" msgid="3564291603258795216">"Aplikasi"</string>
    <string name="storage_documents_and_other" msgid="3293689243732236480">"Dokumen &amp; lainnya"</string>
    <string name="storage_system" msgid="8472410119822911844">"Sistem"</string>
    <string name="storage_trash" msgid="2807138998886084856">"Sampah"</string>
    <string name="storage_trash_dialog_title" msgid="2296169576049935200">"Kosongkan sampah?"</string>
    <string name="storage_trash_dialog_ask_message" msgid="8982602137242358798">"Ada <xliff:g id="TOTAL">%1$s</xliff:g> file di dalam sampah. Semua item akan dihapus selamanya, dan Anda tidak akan dapat memulihkannya."</string>
    <string name="storage_trash_dialog_empty_message" msgid="7334670765528691400">"Sampah kosong"</string>
    <string name="storage_trash_dialog_confirm" msgid="1707723334982760436">"Kosongkan Sampah"</string>
    <string name="storage_usage_summary" msgid="4591121727356723463">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g> digunakan"</string>
    <string name="storage_total_summary" msgid="7163360249534964272">"Total <xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="clear_instant_app_data" msgid="5951258323364386357">"Hapus aplikasi"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Ingin menghapus aplikasi instan ini?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Buka"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Game"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Ruang penyimpanan yang digunakan"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(di-uninstal untuk pengguna <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(dinonaktifkan untuk pengguna <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Layanan isi otomatis"</string>
    <string name="default_autofill_app" msgid="372234803718251606">"Layanan isi otomatis default"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Sandi"</string>
    <string name="credman_chosen_app_title" msgid="4547405511458518096">"Sandi, kunci sandi, dan layanan data"</string>
    <string name="credman_credentials" msgid="4931371941253324143">"Penyedia tambahan"</string>
    <string name="autofill_passwords_count" msgid="6359289285822955973">"{count,plural, =1{# sandi}other{# sandi}}"</string>
    <string name="autofill_keywords" msgid="8598763328489346438">"otomatis, isi, isi otomatis, sandi"</string>
    <string name="credman_keywords" msgid="8305600680836806170">"data, kunci sandi, sandi"</string>
    <string name="credman_autofill_keywords" msgid="701180623776848914">"otomatis, isi, isi otomatis, data, kunci sandi, sandi"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&lt;b&gt;Pastikan Anda memercayai aplikasi ini&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Isi Otomatis Google&gt;%1$s&lt;/xliff:g&gt; menggunakan item yang ada di layar untuk menentukan item apa saja yang dapat diisi otomatis."</string>
    <string name="credman_autofill_confirmation_message" msgid="4951846866327737417">"&lt;b&gt;Gunakan &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt;?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; menggunakan konten di layar untuk menentukan item yang dapat diisi otomatis. Sandi, kunci sandi, dan info baru lainnya akan disimpan di sini mulai sekarang."</string>
    <string name="credman_picker_title" msgid="2642776965060619988">"Sandi, kunci sandi, dan layanan data"</string>
    <string name="credman_confirmation_message_title" msgid="8847900085593880729">"Nonaktifkan %1$s?"</string>
    <string name="credman_confirmation_message" msgid="2357324543658635239">"&lt;b&gt;Nonaktifkan layanan ini?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Info tersimpan seperti sandi, kunci sandi, metode pembayaran, dan info lainnya tidak akan diisikan saat Anda login. Untuk menggunakan info tersimpan, pilih sandi, kunci sandi, atau layanan data."</string>
    <string name="credman_enable_confirmation_message_title" msgid="1037501792652277829">"Gunakan %1$s?"</string>
    <string name="credman_enable_confirmation_message" msgid="8407841892310870169">"%1$s menggunakan item yang ada di layar untuk menentukan item apa yang dapat diisi otomatis."</string>
    <string name="credman_error_message_title" msgid="4741457523969373713">"Batas sandi, kunci sandi, dan layanan data"</string>
    <string name="credman_error_message" msgid="6793314648458925172">"Anda dapat memiliki hingga 5 sandi, kunci sandi, dan layanan data yang aktif secara bersamaan. Nonaktifkan satu layanan untuk menambahkan layanan lain."</string>
    <string name="credman_confirmation_message_positive_button" msgid="2812613187691345361">"Nonaktifkan"</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Isi Otomatis"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Level logging"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Permintaan maks per sesi"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Jumlah set data maks yang terlihat"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Reset ke nilai default"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Opsi developer IsiOtomatis telah direset"</string>
    <string name="location_category" msgid="3496759112306219062">"Lokasi"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Status bar indikator lokasi"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Tampilkan untuk semua lokasi, termasuk jaringan dan konektivitas"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Paksa ukuran GNSS penuh"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Lacak semua konstelasi dan frekuensi GNSS terus-menerus"</string>
    <string name="input_method_category" msgid="2252659253631639005">"Metode Input"</string>
    <string name="stylus_handwriting" msgid="2154591374132794563">"Tulis tangan stilus"</string>
    <string name="stylus_handwriting_summary" msgid="6333425895172696950">"Saat aktif, metode input saat ini akan menerima MotionEvent stilus jika Editor dijadikan fokus."</string>
    <string name="device_theme" msgid="5027604586494772471">"Tema perangkat"</string>
    <string name="default_theme" msgid="4815428567082263639">"Default"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Nama jaringan"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Tampilkan nama jaringan di status bar"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Aplikasi instan"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Nonaktifkan pengelola penyimpanan?"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Perbarui mode Jangan Ganggu"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Jeda notifikasi agar tetap fokus"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Fitur tidak tersedia"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Fitur ini telah dinonaktifkan karena memperlambat ponsel Anda"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Selalu tampilkan dialog error"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Tampilkan dialog setiap kali aplikasi menutup karena error"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Pilih aplikasi yang berkemampuan ANGLE"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Tidak ada aplikasi berkemampuan ANGLE yang ditetapkan"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"Aplikasi yang berkemampuan ANGLE: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Preferensi Driver Grafis"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Ubah setelan driver grafis"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Saat beberapa driver grafis tersedia, Anda dapat memilih untuk menggunakan driver grafis yang sudah diupdate untuk Aplikasi yang diinstal pada perangkat."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Aktifkan untuk semua aplikasi"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Pilih Driver Grafis"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Default"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Driver Game"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Developer Driver"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Driver Grafis Sistem"</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="3985105681812713612">"Aktifkan ANGLE"</string>
    <string name="enable_angle_as_system_driver_summary" msgid="4173041926052925436">"Aktifkan ANGLE sebagai driver OpenGL ES sistem"</string>
    <string name="reboot_dialog_enable_angle_as_system_driver" msgid="2619263039763150810">"Perlu memulai ulang untuk mengubah driver OpenGL ES sistem"</string>
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"Perubahan Kompatibilitas Aplikasi"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Ubah setelan kompatibilitas aplikasi"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Perubahan aktif default"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Perubahan nonaktif default"</string>
    <string name="platform_compat_dialog_title_no_apps" msgid="4387656000745989506">"Aplikasi tidak tersedia"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Perubahan kompatibilitas aplikasi hanya dapat diubah untuk aplikasi yang dapat di-debug. Instal aplikasi yang dapat di-debug dan coba lagi."</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Bergantung pada setelan lain"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Akun"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Nama perangkat"</string>
    <string name="my_device_info_basic_info_category_title" msgid="381963187269356548">"Info dasar"</string>
    <string name="my_device_info_legal_category_title" msgid="7732792841537995127">"Hukum &amp; peraturan"</string>
    <string name="my_device_info_device_details_category_title" msgid="4848438695638348680">"Detail perangkat"</string>
    <string name="my_device_info_device_identifiers_category_title" msgid="2197063484127704153">"ID perangkat"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"Kontrol Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Izinkan aplikasi mengontrol Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Mengizinkan aplikasi ini mengaktifkan atau menonaktifkan Wi-Fi, memindai dan menghubungkan ke jaringan Wi-Fi, menambahkan atau menghapus jaringan, atau memulai hotspot khusus lokal"</string>
    <string name="change_nfc_tag_apps_title" msgid="91514009058149617">"Luncurkan melalui NFC"</string>
    <string name="change_nfc_tag_apps_detail_switch" msgid="240286205725043561">"Izinkan peluncuran saat NFC dipindai"</string>
    <string name="change_nfc_tag_apps_detail_summary" msgid="3338220223868942195">"Izinkan aplikasi ini diluncurkan saat tag NFC dipindai.\nJika izin ini diaktifkan, aplikasi akan tersedia sebagai opsi setiap kali tag terdeteksi."</string>
    <string name="media_output_title" msgid="8283629315159510680">"Putar media ke"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Putar <xliff:g id="LABEL">%s</xliff:g> di"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"Perangkat ini"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Tidak tersedia saat panggilan berlangsung"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Jawab panggilan di"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"APN ini tidak dapat diubah."</string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Cegah berdering"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Tekan tombol Daya &amp; Naikkan Volume secara bersamaan untuk"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Pintasan untuk mencegah berdering"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Getar"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Bisukan"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Bergetar"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Bisukan"</string>
    <string name="prevent_ringing_option_unavailable_lpp_summary" msgid="8070356204398144241">"Untuk mengaktifkan, ubah \"Tekan &amp; tahan tombol daya\" ke menu daya terlebih dahulu."</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Detail jaringan"</string>
    <string name="about_phone_device_name_warning" msgid="1938930553285875166">"Nama perangkat terlihat oleh aplikasi di ponsel, dan juga mungkin dilihat oleh orang lain saat Anda menghubungkan ke perangkat Bluetooth atau jaringan Wi-Fi, atau saat menyiapkan hotspot Wi-Fi."</string>
    <string name="devices_title" msgid="649715719278562515">"Perangkat"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Pilih jaringan"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Terputus"</string>
    <string name="network_connected" msgid="7637745547242487795">"Terhubung"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Menghubungkan…"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Tidak dapat terhubung"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"Jaringan tidak ditemukan."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Tidak dapat menemukan jaringan. Coba lagi."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(terlarang)"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"Tidak ada SIM"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Tidak ada"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Memerlukan SIM agar terhubung"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Memerlukan SIM <xliff:g id="WIRELESS_CARRIER">%s</xliff:g> agar terhubung"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Mode jaringan pilihan: WCDMA dipilih"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Mode jaringan pilihan: hanya GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Mode jaringan pilihan: hanya WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Mode jaringan pilihan: GSM / WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Mode jaringan pilihan: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Mode jaringan pilihan: CDMA / EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Mode jaringan pilihan: hanya CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Mode jaringan pilihan: hanya EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Mode jaringan pilihan: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Mode jaringan pilihan: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Mode jaringan pilihan: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Mode jaringan pilihan: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Mode jaringan pilihan: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Mode jaringan pilihan: Global"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Mode jaringan pilihan: LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Mode jaringan pilihan: LTE / GSM / UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Mode jaringan pilihan: LTE / CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Mode jaringan pilihan: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Mode jaringan pilihan: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Mode jaringan pilihan: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Mode jaringan pilihan: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Mode jaringan pilihan: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Mode jaringan pilihan: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Mode jaringan pilihan: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Mode jaringan pilihan: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Mode jaringan pilihan: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Mode jaringan pilihan: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Mode jaringan pilihan: khusus NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Mode jaringan pilihan: NR / LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Mode jaringan pilihan: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Mode jaringan pilihan: NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Mode jaringan pilihan: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Mode jaringan pilihan: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Mode jaringan pilihan: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Mode jaringan pilihan: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Mode jaringan pilihan: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Mode jaringan pilihan: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Mode jaringan pilihan: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_5G_recommended" msgid="4769018972369031538">"5G (disarankan)"</string>
    <string name="network_lte" msgid="2449425437381668780">"LTE (disarankan)"</string>
    <string name="network_4G" msgid="9018841362928321047">"4G (disarankan)"</string>
    <string name="select_automatically" msgid="2419752566747259155">"Pilih jaringan secara otomatis"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Setelan operator"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Siapkan layanan data"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Data seluler"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Akses data menggunakan jaringan seluler"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"Ponsel akan otomatis beralih ke operator ini saat berada dalam jangkauan"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="9176513507571883986">"Tidak ada SIM yang tersedia"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Preferensi panggilan"</string>
    <string name="sms_preference" msgid="7742964962568219351">"Preferensi SMS"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Selalu tanya"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Tambahkan jaringan"</string>
    <string name="default_for_calls" msgid="2788950217176988034">"Default untuk panggilan telepon"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"Default untuk SMS"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"Default untuk panggilan telepon &amp; SMS"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"Default untuk data seluler"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Data seluler aktif"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Kuota nonaktif"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Tersedia"</string>
    <string name="mobile_network_list_add_more" msgid="5076722903436552813">"Tambahkan SIM"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Aktif / SIM"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Tidak aktif / SIM"</string>
    <string name="mobile_network_active_esim" msgid="3984452275968408382">"Aktif/eSIM"</string>
    <string name="mobile_network_inactive_esim" msgid="8777415108263057939">"Tidak aktif/eSIM"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"Nama &amp; warna SIM"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Nama"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Warna (digunakan oleh apl kompatibel)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Simpan"</string>
    <string name="mobile_network_use_sim_on" msgid="7298332437547707908">"Gunakan SIM"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Nonaktif"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="2851862257846773796">"Untuk menonaktifkan SIM ini, keluarkan kartu SIM"</string>
    <string name="mobile_network_tap_to_activate" msgid="4139979375717958102">"Ketuk untuk mengaktifkan <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="4629071168032714930">"Hapus SIM"</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Preferensi jenis jaringan"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Ubah mode pengoperasian jaringan"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Preferensi jenis jaringan"</string>
    <string name="carrier_settings_version" msgid="3364919669057317776">"Versi setelan operator"</string>
    <string name="call_category" msgid="641461844504128789">"Memanggil"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Panggilan video operator"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Pilih sistem"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"Mengubah mode roaming CDMA"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Pilih sistem"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Jaringan"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"Langganan CDMA"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Mengubah antara RUIM/SIM dan NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"langganan"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Pendaftaran otomatis..."</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Izinkan roaming data?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Hubungi penyedia jaringan untuk mengetahui harganya."</string>
    <string name="mobile_data_usage_title" msgid="2047864499317759728">"Penggunaan data oleh aplikasi"</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"Mode Jaringan Tidak Valid <xliff:g id="NETWORKMODEID">%1$d</xliff:g>. Abaikan."</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Nama Titik Akses"</string>
    <string name="keywords_access_point_names" msgid="8174967126858505945">"apn"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Tidak tersedia saat terhubung ke <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"Lihat lainnya"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"Aktifkan <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name" msgid="4842051610633654278">"Aktifkan SIM?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"Beralih ke <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"Beralih menggunakan kartu SIM?"</string>
    <string name="sim_action_switch_sub_dialog_mep_title" msgid="933856847099933004">"Gunakan <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="2091834911153293004">"Hanya satu SIM yang dapat diaktifkan pada satu waktu.\n\nBeralih ke <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> tidak akan membatalkan layanan <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="8977951796005849471">"Hanya 1 eSIM yang dapat aktif pada satu waktu.\n\nBeralih ke <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> tidak akan membatalkan layanan <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="6188750682431170845">"Hanya satu SIM yang dapat diaktifkan pada satu waktu.\n\nPengalihan tidak akan membatalkan layanan <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_mep_text" msgid="8348764755143679582">"Anda tidak dapat menggunakan 2 SIM sekaligus. Untuk menggunakan <xliff:g id="CARRIER_NAME">%1$s</xliff:g>, nonaktifkan SIM lainnya."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Alihkan ke <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">"Nonaktifkan <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_info_outline_for_turning_off" msgid="1617619100229136888">"Menonaktifkan SIM tidak akan membatalkan paket seluler Anda"</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="2706862823501979981">"Menghubungkan ke jaringan…"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="4718412054243793310">"Mengalihkan ke <xliff:g id="CARRIER_NAME">%1$s</xliff:g> untuk panggilan telepon dan SMS …"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="1765646238941015899">"Tidak dapat mengalihkan operator"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="4781863235721417544">"Operator tidak dapat dialihkan karena error."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"Nonaktifkan <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"Nonaktifkan SIM?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"Menonaktifkan SIM <xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="6689494935697043555">"Tidak dapat menonaktifkan operator"</string>
    <string name="privileged_action_disable_fail_text" msgid="8404023523406091819">"Terjadi error dan operator Anda tidak dapat dinonaktifkan."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"Gunakan 2 SIM?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"Perangkat ini dapat memiliki 2 SIM aktif sekaligus. Untuk terus menggunakan 1 SIM pada satu waktu, ketuk \"Lain kali\"."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Mulai ulang perangkat?"</string>
    <string name="sim_action_yes" msgid="8076556020131395515">"Ya"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Mulai ulang"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"Lain kali"</string>
    <string name="sim_action_cancel" msgid="2668099867029610910">"Batal"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Alihkan"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"Tidak dapat mengaktifkan SIM"</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Coba aktifkan SIM lagi. Jika masalah berlanjut, mulai ulang perangkat."</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Aktivasi jaringan"</string>
    <string name="sim_switch_channel_id" msgid="4927038626791837861">"Beralih operator"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="3308827462185135307">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> aktif"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Ketuk untuk memperbarui setelan SIM"</string>
    <string name="switch_to_removable_notification" msgid="7640342063449806296">"Dialihkan ke <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="switch_to_removable_notification_no_carrier_name" msgid="7384856964036215338">"Dialihkan ke operator lain"</string>
    <string name="network_changed_notification_text" msgid="2407908598496951243">"Jaringan seluler Anda telah berubah"</string>
    <string name="dsds_notification_after_suw_title" msgid="3738898232310273982">"Siapkan SIM lainnya"</string>
    <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"Pilih SIM yang aktif atau gunakan 2 SIM sekaligus"</string>
    <string name="choose_sim_title" msgid="4804689675237716286">"Pilih nomor yang akan digunakan"</string>
    <string name="choose_sim_text" msgid="4356662002583501647">"{count,plural, =1{Tersedia 1 nomor di perangkat ini, tetapi hanya satu nomor yang dapat digunakan dalam satu waktu}=2{Tersedia 2 nomor di perangkat ini, tetapi hanya satu nomor yang dapat digunakan dalam satu waktu}other{Tersedia # nomor di perangkat ini, tetapi hanya satu nomor yang dapat digunakan dalam satu waktu}}"</string>
    <string name="choose_sim_activating" msgid="9035902671985449448">"Mengaktifkan <xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="choose_sim_could_not_activate" msgid="2154564459842291617">"Tidak dapat diaktifkan sekarang"</string>
    <string name="switch_sim_dialog_title" msgid="5407316878973237773">"Gunakan <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> akan digunakan untuk data seluler, panggilan, dan SMS."</string>
    <string name="switch_sim_dialog_no_switch_title" msgid="809763410787744247">"Tidak ada SIM aktif yang tersedia"</string>
    <string name="switch_sim_dialog_no_switch_text" msgid="7053939850026876088">"Untuk menggunakan data seluler, fitur panggilan, dan SMS di lain waktu, buka setelan jaringan"</string>
    <string name="sim_card_label" msgid="6263064316075963775">"SIM"</string>
    <string name="erase_sim_dialog_title" msgid="4742077437653028326">"Hapus eSIM ini?"</string>
    <string name="erase_sim_dialog_text" msgid="753031064269699885">"Menghapus SIM ini akan menghapus layanan <xliff:g id="CARRIER_NAME_A">%1$s</xliff:g> dari perangkat ini.\n\nLayanan untuk <xliff:g id="CARRIER_NAME_B">%1$s</xliff:g> tidak akan dibatalkan."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Hapus"</string>
    <string name="erasing_sim" msgid="7877703231075699139">"Menghapus SIM …"</string>
    <string name="erase_sim_fail_title" msgid="2024446702985862427">"Tidak dapat menghapus SIM"</string>
    <string name="erase_sim_fail_text" msgid="7870804401227483131">"SIM ini tidak dapat dihapus karena terjadi error.\n\nMulai ulang perangkat, lalu coba lagi."</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Hubungkan ke perangkat"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"Aplikasi <xliff:g id="APPNAME">%1$s</xliff:g> ingin menggunakan jaringan Wi-Fi sementara untuk terhubung ke perangkat"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Perangkat tidak ditemukan. Pastikan perangkat dihidupkan dan dapat terhubung ke jaringan."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Coba lagi"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Terjadi error. Aplikasi telah membatalkan permintaan untuk memilih perangkat."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Koneksi berhasil"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Koneksi gagal"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Tampilkan semua"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Menelusuri perangkat…"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Menghubungkan ke perangkat…"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Kiri"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Kanan"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Casing"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Panel Setelan"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Paksa mode desktop"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Paksa mode desktop eksperimental di layar sekunder"</string>
    <string name="enable_non_resizable_multi_window" msgid="6832903754625404477">"Aktifkan ukuran tidak dapat diubah di multi-jendela"</string>
    <string name="enable_non_resizable_multi_window_summary" msgid="3275763753261901999">"Izinkan aplikasi yang ukurannya tidak dapat diubah di multi-jendela"</string>
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Aktifkan Gelap Otomatis"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Buat agar fitur Gelap Otomatis selalu aktif"</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Privasi"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Izin, aktivitas akun, data pribadi"</string>
    <string name="privacy_controls_title" msgid="1383047169455206604">"Kontrol"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Hapus"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Simpan"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"Hapus saran ini?"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Penyimpanan hampir penuh. <xliff:g id="PERCENTAGE">%1$s</xliff:g> digunakan - <xliff:g id="FREE_SPACE">%2$s</xliff:g> kosong"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Kirim masukan"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Ingin memberikan masukan tentang saran ini?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"<xliff:g id="COPY_CONTENT">%1$s</xliff:g> disalin ke papan klip."</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Penggunaan aksesibilitas"</string>
    <string name="accessibility_usage_summary" msgid="4348285359995227813">"{count,plural, =1{1 aplikasi memiliki akses penuh ke perangkat Anda}other{# aplikasi memiliki akses penuh ke perangkat Anda}}"</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Informasi penting"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"LANJUTKAN"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"TIDAK, TERIMA KASIH"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Lokasi"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="1417004513415772582">"Operator dapat mengumpulkan informasi lokasi Anda saat layanan ini digunakan untuk panggilan darurat.\n\nLihat kebijakan privasi operator Anda untuk mengetahui detailnya."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Anda dapat kehilangan akses ke waktu atau data apa pun yang tersisa. Hubungi penyedia Anda sebelum menghapus."</string>
    <string name="content_capture" msgid="868372905432812238">"Konten aplikasi"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Izinkan aplikasi mengirimkan konten ke sistem Android"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Ambil heap dump sistem"</string>
    <string name="development_memtag_page_title" msgid="3546667618748029188">"Memory Tagging Extension"</string>
    <string name="development_memtag_intro" msgid="8032596625527637164">"Memory Tagging Extension (MTE) memudahkan penemuan masalah keamanan memori di aplikasi dan membuat kode native di aplikasi lebih aman."</string>
    <string name="development_memtag_footer" msgid="5681925148773626562">"Mengaktifkan MTE dapat membuat perangkat bekerja lebih lambat."</string>
    <string name="development_memtag_learn_more" msgid="8961984806973926704">"Pelajari MTE lebih lanjut"</string>
    <string name="development_memtag_toggle" msgid="2474420239518386894">"Aktifkan MTE hingga Anda menonaktifkannya"</string>
    <string name="development_memtag_reboot_message_on" msgid="8100075676107327847">"Anda harus memulai ulang perangkat untuk mengaktifkan MTE."</string>
    <string name="development_memtag_reboot_message_off" msgid="3703925647922079456">"Anda harus memulai ulang perangkat untuk menonaktifkan MTE."</string>
    <string name="reboot_with_mte_title" msgid="2320125810211279">"Aktifkan MTE untuk satu sesi"</string>
    <string name="reboot_with_mte_message" msgid="1232881567956207641">"Sistem akan dimulai ulang dan mengizinkan eksperimen dengan Memory Tagging Extension (MTE). MTE dapat berdampak negatif pada performa dan stabilitas sistem. Akan direset pada mulai ulang berikutnya."</string>
    <string name="reboot_with_mte_summary" msgid="3896537791216432882">"Mulai ulang untuk satu sesi dengan MTE diaktifkan"</string>
    <string name="reboot_with_mte_already_enabled" msgid="4439168867613407167">"MTE telah diaktifkan"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Mengambil heap dump sistem"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Tidak dapat mengambil heap dump sistem"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Otomatis ambil heap dump sistem"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Otomatis ambil heap dump untuk Sistem Android saat sistem menggunakan terlalu banyak memori"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Putuskan koneksi"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Panggilan darurat"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"Panggilan darurat melalui Panggilan Wi‑Fi tidak didukung oleh operator Anda.\nPerangkat beralih ke jaringan seluler secara otomatis untuk melakukan panggilan darurat.\nPanggilan darurat hanya dapat dilakukan dengan cakupan seluler."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Gunakan Wi‑Fi untuk melakukan panggilan dengan kualitas lebih baik"</string>
    <string name="backup_calling_settings_title" msgid="519714752900364326">"Panggilan cadangan"</string>
    <string name="backup_calling_setting_summary" msgid="599493254305348733">"Jika <xliff:g id="BACKUP_CALLING_OPERATOR_TEXT">%1$s</xliff:g> tidak tersedia atau sedang roaming, gunakan SIM data seluler untuk panggilan <xliff:g id="BACKUP_CALLING_CARRIER_TEXT">%1$s</xliff:g>."</string>
    <string name="keywords_backup_calling" msgid="8592800915478816800">"panggilan cadangan"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Pesan MMS masuk"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"Tidak dapat mengirim pesan MMS"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Ketuk untuk mengizinkan pengiriman pesan MMS menggunakan <xliff:g id="OPERATOR_NAME">%1$s</xliff:g> saat kuota nonaktif"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"Pesan MMS"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Masalah dengan kombinasi SIM"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Penggunaan <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g> dapat membatasi ketersediaan fitur. Ketuk untuk mempelajari lebih lanjut."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"Kombinasi SIM"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Info kebijakan profil kerja Anda"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Setelan yang dikelola oleh admin IT"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"GPU"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Pengendali laporan bug"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Menentukan aplikasi mana yang menangani pintasan Laporan Bug di perangkat."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Pribadi"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Kerja"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Default sistem"</string>
    <string name="default_app_none" msgid="5420632042222036264">"Tidak ada"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"Pilihan ini tidak valid lagi. Coba lagi."</string>
    <string name="power_menu_setting_name" msgid="2394440932633137229">"Tekan &amp; tahan tombol daya"</string>
    <string name="power_menu_long_press_category_title" msgid="1051146091093775002">"Tekan dan tahan tombol daya untuk mengakses"</string>
    <string name="power_menu_long_press_for_power_menu_title" msgid="477584639843663599">"Menu daya"</string>
    <string name="power_menu_long_press_for_assistant_title" msgid="6557738348262616455">"Asisten digital"</string>
    <string name="power_menu_summary_long_press_for_assistant" msgid="32706459458422952">"Mengakses asisten digital"</string>
    <string name="power_menu_summary_long_press_for_power_menu" msgid="7617247135239683710">"Mengakses menu daya"</string>
    <string name="lockscreen_privacy_not_secure" msgid="3251276389681975912">"Untuk menggunakannya, setel kunci layar terlebih dahulu"</string>
    <string name="power_menu_power_volume_up_hint" msgid="5619917593676125759">"Menu daya:\nTekan tombol daya dan tombol naikkan volume secara bersamaan"</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="1169955014711158873">"Mencegah dering:\nTekan tombol volume untuk menggunakan pintasan"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_title" msgid="1626808509158422185">"Durasi tekan &amp; tahan"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_summary" msgid="7550610071666801935">"Sesuaikan sensitivitas dengan memilih durasi menekan &amp; menahan tombol daya"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_low_label" msgid="3430099983480845635">"Singkat"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_high_label" msgid="2059686170350829156">"Lama"</string>
    <string name="lockscreen_privacy_wallet_setting_toggle" msgid="4188327143734192000">"Tampilkan Wallet"</string>
    <string name="lockscreen_privacy_wallet_summary" msgid="3984851951621168573">"Mengizinkan akses ke Wallet dari layar kunci"</string>
    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle" msgid="1856477548806618829">"Tampilkan pemindai kode QR"</string>
    <string name="lockscreen_privacy_qr_code_scanner_summary" msgid="4577409244972250235">"Izinkan akses ke pemindai kode QR dari layar kunci"</string>
    <string name="lockscreen_privacy_controls_setting_toggle" msgid="7445725343949588613">"Tampilkan kontrol perangkat"</string>
    <string name="lockscreen_privacy_controls_summary" msgid="7522918441738915364">"Dari layar kunci"</string>
    <string name="lockscreen_trivial_controls_setting_toggle" msgid="2174300719855112358">"Gunakan kontrol perangkat"</string>
    <string name="lockscreen_trivial_disabled_controls_summary" msgid="7593626010580689155">"Untuk menggunakannya, aktifkan \"Tampilkan kontrol perangkat\" terlebih dahulu"</string>
    <string name="lockscreen_double_line_clock_summary" msgid="2916159550425093703">"Tampilkan jam dua baris jika tersedia"</string>
    <string name="lockscreen_double_line_clock_setting_toggle" msgid="3408639316001688529">"Jam dua baris"</string>
    <string name="lockscreen_quick_affordances_title" msgid="8615741551327565793">"Pintasan"</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">"Nonaktifkan VoLTE?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"Ini juga menonaktifkan koneksi 5G.\nSelama panggilan suara, Anda tidak dapat menggunakan internet dan beberapa aplikasi mungkin tidak berfungsi."</string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Tangguhkan eksekusi aplikasi yang di-cache"</string>
    <string name="blob_never_expires_text" msgid="7293376386620106623">"Akan terus berlaku."</string>
    <string name="accessor_never_expires_text" msgid="4647624492147788340">"Lease akan terus berlaku."</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Izinkan overlay layar pada Setelan"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Izinkan aplikasi yang dapat ditampilkan di atas aplikasi lain untuk melakukan overlay layar Setelan"</string>
    <string name="allow_mock_modem" msgid="3832264806530479214">"Izinkan Modem Simulasi"</string>
    <string name="allow_mock_modem_summary" msgid="9097416612748005374">"Izinkan perangkat ini menjalankan layanan Modem Simulasi untuk uji instrumentasi. Jangan aktifkan selama penggunaan normal ponsel"</string>
    <string name="media_controls_title" msgid="403271085636252597">"Media"</string>
    <string name="media_controls_resume_title" msgid="855076860336652370">"Sematkan pemutar media"</string>
    <string name="media_controls_resume_description" msgid="3163482266454802097">"Untuk melanjutkan pemutaran dengan cepat, pemutar media tetap terbuka di Setelan Cepat"</string>
    <string name="media_controls_lockscreen_title" msgid="2188311721857512510">"Tampilkan media di layar kunci"</string>
    <string name="media_controls_lockscreen_description" msgid="3320333660404439510">"Untuk melanjutkan pemutaran dengan cepat, pemutar media tetap terbuka di layar kunci"</string>
    <string name="media_controls_recommendations_title" msgid="184225835236807677">"Tampilkan rekomendasi media"</string>
    <string name="media_controls_recommendations_description" msgid="7596498733126824030">"Berdasarkan aktivitas Anda"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Sembunyikan pemutar"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Tampilkan pemutar"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"media"</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"Bluetooth akan diaktifkan"</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"Internet"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"SIM"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Panggilan Telepon &amp; SMS"</string>
    <string name="calls_and_sms_category" msgid="3788238090898237767">"Panggilan Wi-Fi"</string>
    <string name="calls_sms_wfc_summary" msgid="3940529919408667336">"Melakukan dan menerima panggilan melalui Wi‑Fi"</string>
    <string name="calls_preference_title" msgid="7536882032182563800">"Panggilan Telepon"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"SMS"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"preferensi"</string>
    <string name="calls_sms_calls_preferred" msgid="9004261125829377885">"dipilih untuk panggilan"</string>
    <string name="calls_sms_sms_preferred" msgid="3855778890660922711">"dipilih untuk SMS"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"tidak tersedia"</string>
    <string name="calls_sms_temp_unavailable" msgid="8602291749338757424">"Tidak tersedia untuk sementara"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"Tidak ada SIM"</string>
    <string name="network_and_internet_preferences_title" msgid="8635896466814033405">"Preferensi jaringan"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"koneksi jaringan, internet, nirkabel, data, wifi, wi-fi, wi fi, seluler, (perangkat) seluler, operator seluler, 4g, 3g, 2g, lte"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Reset internet?"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Mereset internet …"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Perbaiki konektivitas"</string>
    <string name="networks_available" msgid="3299512933684383474">"Jaringan tersedia"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Untuk beralih jaringan, lepaskan kabel ethernet"</string>
    <string name="carrier_wifi_offload_title" msgid="7263365988016247722">"Koneksi W+"</string>
    <string name="carrier_wifi_offload_summary" msgid="2980563718888371142">"Izinkan Google Fi menggunakan jaringan W+ untuk meningkatkan kecepatan dan cakupan"</string>
    <string name="carrier_wifi_network_title" msgid="5461382943873831770">"Jaringan 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="1503823567818544012">"Aktif"</string>
    <string name="sim_category_inactive_sim" msgid="4068899490133820881">"Tidak aktif"</string>
    <string name="sim_category_default_active_sim" msgid="1208194173387987231">" / Default untuk <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="default_active_sim_calls" msgid="2390973682556353558">"panggilan telepon"</string>
    <string name="default_active_sim_sms" msgid="8041498593025994921">"SMS"</string>
    <string name="default_active_sim_mobile_data" msgid="6798083892814045301">"data seluler"</string>
    <string name="wifi_scan_notify_message" msgid="1331238142061476869">"Untuk meningkatkan fungsi perangkat, aplikasi dan layanan tetap dapat memindai jaringan Wi-Fi kapan saja, bahkan saat Wi-Fi nonaktif. Ini dapat digunakan, misalnya, untuk meningkatkan kualitas fitur dan layanan berbasis lokasi. Anda dapat mengubahnya di setelan pemindaian Wi‑Fi."</string>
    <string name="wifi_scan_change" msgid="8438320311511852918">"Ubah"</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">"Terhubung"</string>
    <string name="mobile_data_temp_connection_active" msgid="3430470299756236413">"Terhubung sementara"</string>
    <string name="mobile_data_temp_using" msgid="5211002380149434155">"Menggunakan <xliff:g id="SUBNAME">%1$s</xliff:g> untuk sementara"</string>
    <string name="mobile_data_no_connection" msgid="905897142426974030">"Tidak ada koneksi"</string>
    <string name="mobile_data_off_summary" msgid="1884248776904165539">"Data seluler tidak akan terhubung otomatis"</string>
    <string name="mobile_data_disable_title" msgid="8438714772256088913">"Nonaktifkan data seluler?"</string>
    <string name="mobile_data_disable_message" msgid="7829414836454769970">"Anda tidak akan memiliki akses ke data atau internet melalui <xliff:g id="CARRIER">%s</xliff:g>. Internet hanya akan tersedia melalui Wi-Fi."</string>
    <string name="mobile_data_disable_message_default_carrier" msgid="4449469407705838612">"operator Anda"</string>
    <string name="not_allowed_by_ent" msgid="1958611623122304411">"Tidak diizinkan oleh organisasi Anda"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Tidak tersedia karena mode waktu tidur diaktifkan"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Reset nilai penting notifikasi selesai."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Aplikasi"</string>
    <string name="bluetooth_message_access_notification_content" msgid="5111712860712823893">"Sebuah perangkat ingin mengakses pesan Anda. Ketuk untuk melihat detailnya."</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Izinkan akses ke pesan?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="7186694737578788487">"Sebuah perangkat Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, ingin mengakses pesan Anda.\n\nAnda belum pernah terhubung ke <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> sebelumnya."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="9175220052703433637">"Sebuah perangkat ingin mengakses kontak dan log panggilan Anda. Ketuk untuk melihat detailnya."</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Izinkan akses ke kontak dan log panggilan?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"Sebuah perangkat Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, ingin mengakses kontak dan log panggilan Anda. Ini mencakup data tentang panggilan masuk dan keluar.\n\nAnda belum pernah terhubung ke <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> sebelumnya."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Kecerahan"</string>
    <string name="category_name_lock_display" msgid="8310402558217129670">"Tampilan layar kunci"</string>
    <string name="category_name_appearance" msgid="8287486771764166805">"Tampilan"</string>
    <string name="category_name_color" msgid="937514550918977151">"Warna"</string>
    <string name="category_name_display_controls" msgid="7046581691184725216">"Kontrol tampilan lainnya"</string>
    <string name="category_name_general" msgid="7737273712848115886">"Umum"</string>
    <string name="dark_theme_main_switch_title" msgid="4045147031947562280">"Gunakan Tema gelap"</string>
    <string name="bluetooth_main_switch_title" msgid="8409835540311309632">"Gunakan Bluetooth"</string>
    <string name="prevent_ringing_main_switch_title" msgid="4726252811262086643">"Gunakan cegah berdering"</string>
    <string name="use_wifi_hotsopt_main_switch_title" msgid="3909731167290690539">"Gunakan hotspot Wi-Fi"</string>
    <string name="app_pinning_main_switch_title" msgid="5465506660064032876">"Gunakan penyematan aplikasi"</string>
    <string name="developer_options_main_switch_title" msgid="1720074589554152501">"Gunakan opsi developer"</string>
    <string name="default_print_service_main_switch_title" msgid="4697133737128324036">"Gunakan layanan cetak"</string>
    <string name="multiple_users_main_switch_title" msgid="6686858308083037810">"Izinkan multi-pengguna"</string>
    <string name="multiple_users_main_switch_keywords" msgid="4845954458094134356">"izinkan, beberapa, pengguna, izin, banyak"</string>
    <string name="wireless_debugging_main_switch_title" msgid="8463499572781441719">"Gunakan proses debug nirkabel"</string>
    <string name="graphics_driver_main_switch_title" msgid="6125172901855813790">"Menggunakan preferensi driver grafis"</string>
    <string name="night_light_main_switch_title" msgid="3428298022467805219">"Gunakan Cahaya Malam"</string>
    <string name="nfc_main_switch_title" msgid="6295839988954817432">"Gunakan NFC"</string>
    <string name="adaptive_brightness_main_switch_title" msgid="2681666805191642737">"Gunakan kecerahan adaptif"</string>
    <string name="wifi_calling_main_switch_title" msgid="4070224008346815634">"Menggunakan panggilan Wi-Fi"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Lihat semua aplikasi"</string>
    <string name="smart_forwarding_title" msgid="8368634861971949799">"Smart Forwarding"</string>
    <string name="smart_forwarding_summary_enabled" msgid="3341062878373185604">"Smart Forwarding Diaktifkan"</string>
    <string name="smart_forwarding_summary_disabled" msgid="5033880700091914809">"Smart Forwarding Dinonaktifkan"</string>
    <string name="smart_forwarding_ongoing_title" msgid="962226849074401228">"Setelan Panggilan"</string>
    <string name="smart_forwarding_ongoing_text" msgid="2189209372407117114">"Memperbarui Setelan ..."</string>
    <string name="smart_forwarding_failed_title" msgid="1859891191023516080">"Error Setelan panggilan"</string>
    <string name="smart_forwarding_failed_text" msgid="8682640643264071789">"Error jaringan atau SIM."</string>
    <string name="smart_forwarding_failed_not_activated_text" msgid="997396203001257904">"Sim tidak diaktifkan."</string>
    <string name="smart_forwarding_input_mdn_title" msgid="5105463748849841763">"Masukkan Nomor telepon"</string>
    <string name="smart_forwarding_input_mdn_dialog_title" msgid="7542216086697868415">"Masukkan Nomor telepon"</string>
    <string name="smart_forwarding_missing_mdn_text" msgid="2907314684242542226">"Tidak ada nomor telepon."</string>
    <string name="smart_forwarding_missing_alert_dialog_text" msgid="7870419247987316112">"Oke"</string>
    <string name="enable_2g_title" msgid="8184757884636162942">"Izinkan 2G"</string>
    <string name="enable_2g_summary" msgid="2794534052372565914">"Jaringan 2G kurang aman, tetapi dapat memperbaiki koneksi Anda di beberapa lokasi. Jaringan 2G selalu diizinkan untuk panggilan darurat."</string>
    <string name="enable_2g_summary_disabled_carrier" msgid="8141118453219482762">"<xliff:g id="CARRIER_NAME_2G">%1$s</xliff:g> mengharuskan jaringan 2G tersedia"</string>
    <string name="require_cellular_encryption_title" msgid="7516008146269371585">"Wajibkan enkripsi"</string>
    <string name="require_cellular_encryption_summary" msgid="4813823321032908641">"Enkripsi lebih aman, tetapi Anda mungkin tidak dapat melakukan panggilan di beberapa lokasi. Untuk panggilan darurat, enkripsi tidak diperlukan"</string>
    <string name="app_info_all_services_label" msgid="1487070364839071105">"Semua layanan"</string>
    <string name="show_clip_access_notification" msgid="7782300987639778542">"Tampilkan akses papan klip"</string>
    <string name="show_clip_access_notification_summary" msgid="474090757777203207">"Tampilkan pesan saat aplikasi mengakses teks, gambar, atau konten lain yang telah Anda salin"</string>
    <string name="all_apps" msgid="3054120149509114789">"Semua aplikasi"</string>
    <string name="request_manage_bluetooth_permission_dont_allow" msgid="8798061333407581300">"Jangan izinkan"</string>
    <string name="uwb_settings_title" msgid="8578498712312002231">"Ultra-Wideband (UWB)"</string>
    <string name="uwb_settings_summary" msgid="3074271396764672268">"Membantu mengidentifikasi posisi relatif perangkat di sekitar yang memiliki UWB"</string>
    <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Nonaktifkan mode pesawat untuk menggunakan UWB"</string>
    <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB tidak tersedia di lokasi saat ini"</string>
    <string name="camera_toggle_title" msgid="8952668677727244992">"Akses kamera"</string>
    <string name="mic_toggle_title" msgid="265145278323852547">"Akses mikrofon"</string>
    <string name="perm_toggle_description" msgid="5754629581767319022">"Untuk aplikasi dan layanan"</string>
    <string name="mic_toggle_description" msgid="484139688645092237">"Untuk aplikasi dan layanan. Jika setelan ini nonaktif, data mikrofon mungkin tetap dibagikan saat Anda menelepon nomor darurat."</string>
    <string name="previous_page_content_description" msgid="6438292457923282991">"Sebelumnya"</string>
    <string name="next_page_content_description" msgid="1641835099813416294">"Berikutnya"</string>
    <string name="colors_viewpager_content_description" msgid="2591751086138259565">"Pratinjau warna"</string>
    <string name="bluetooth_sim_card_access_notification_title" msgid="7351015416346359536">"Permintaan akses SIM"</string>
    <string name="bluetooth_sim_card_access_notification_content" msgid="8685623260103018309">"Sebuah perangkat ingin mengakses SIM Anda. Ketuk untuk melihat detailnya."</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="5616323725563125179">"Izinkan akses ke SIM?"</string>
    <string name="bluetooth_sim_card_access_dialog_content" msgid="6281997628405909566">"Perangkat Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, ingin mengakses data dari SIM Anda. Data ini mencakup kontak Anda.\n\nSaat terhubung, <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> akan menerima semua panggilan yang masuk ke <xliff:g id="PHONE_NUMBER">%3$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_notification_title" msgid="2573547043170883947">"Perangkat Bluetooth tersedia"</string>
    <string name="bluetooth_connect_access_notification_content" msgid="1328465545685433304">"Sebuah perangkat ingin terhubung. Ketuk untuk melihat detailnya."</string>
    <string name="bluetooth_connect_access_dialog_title" msgid="1948056782712451381">"Hubungkan ke perangkat Bluetooth?"</string>
    <string name="bluetooth_connect_access_dialog_content" msgid="4336436466468405850">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> ingin terhubung ke ponsel ini.\n\nAnda belum pernah terhubung ke <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> sebelumnya."</string>
    <string name="bluetooth_connect_access_dialog_negative" msgid="4944672755226375059">"Jangan hubungkan"</string>
    <string name="bluetooth_connect_access_dialog_positive" msgid="3630561675207269710">"Hubungkan"</string>
    <string name="tare_settings" msgid="3788654800004869077">"Setelan TARE"</string>
    <string name="tare_on" msgid="2386073225978684535">"Aktif"</string>
    <string name="tare_off" msgid="6305694402929756726">"Nonaktif"</string>
    <string name="tare_revert" msgid="3855325741125236638">"Kembalikan ke Setelan Default"</string>
    <string name="tare_settings_reverted_toast" msgid="8189887409285176731">"Setelan dikembalikan ke default."</string>
    <string name="tare_max_satiated_balance" msgid="3914973999573150340">"Saldo Maksimum Saat Baterai Terisi Penuh"</string>
    <string name="tare_balances" msgid="731881382594747961">"Saldo"</string>
    <string name="tare_consumption_limits" msgid="3230949387874396382">"Batas Penggunaan"</string>
    <string name="tare_initial_consumption_limit" msgid="2921646306374048384">"Batas Penggunaan Awal"</string>
    <string name="tare_min_consumption_limit" msgid="3293145670921755789">"Batas Penggunaan Minimum"</string>
    <string name="tare_max_consumption_limit" msgid="8335700580111808823">"Batas Penggunaan Maksimum"</string>
    <string name="tare_modifiers" msgid="8919975635360280820">"Pengubah"</string>
    <string name="tare_actions_ctp" msgid="5110104015354916401">"Tindakan (Biaya Produksi)"</string>
    <string name="tare_actions_base_price" msgid="3300967942666376589">"Tindakan (Harga Dasar)"</string>
    <string name="tare_rewards_instantaneous" msgid="8358683519945340874">"Reward per satu acara"</string>
    <string name="tare_rewards_ongoing" msgid="7657030286658143416">"Reward per detik durasi peristiwa"</string>
    <string name="tare_rewards_max" msgid="5283055625642837010">"Reward Maksimum Per Hari"</string>
    <string name="tare_app_install" msgid="7955806910408116882">"Penginstalan Aplikasi"</string>
    <string name="tare_top_activity" msgid="7266560655483385757">"Aktivitas Teratas"</string>
    <string name="tare_notification_seen" msgid="7829963536020087742">"Notifikasi Sudah Dilihat"</string>
    <string name="tare_notification_seen_15_min" msgid="832174185809497764">"Notifikasi Sudah Dilihat dalam 15 Menit"</string>
    <string name="tare_notification_interaction" msgid="3806204222322830129">"Interaksi Notifikasi"</string>
    <string name="tare_widget_interaction" msgid="2260701564089214184">"Interaksi Widget"</string>
    <string name="tare_other_interaction" msgid="8069163421115212751">"Interaksi Pengguna Lainnya"</string>
    <string name="tare_job_max_start" msgid="1586399578665940836">"Tugas Prioritas Maksimum Dimulai"</string>
    <string name="tare_job_max_running" msgid="2897217372986518495">"Tugas Prioritas Maksimum Berjalan"</string>
    <string name="tare_job_high_start" msgid="7464143754932031022">"Tugas Prioritas Tinggi Dimulai"</string>
    <string name="tare_job_high_running" msgid="6541171046405088669">"Tugas Prioritas Tinggi Berjalan"</string>
    <string name="tare_job_default_start" msgid="6744427210148953151">"Tugas Prioritas Default Dimulai"</string>
    <string name="tare_job_default_running" msgid="8429081804128945217">"Tugas Prioritas Default Berjalan"</string>
    <string name="tare_job_low_start" msgid="4605440035856891746">"Tugas Prioritas Rendah Dimulai"</string>
    <string name="tare_job_low_running" msgid="831668616902849604">"Tugas Prioritas Rendah Berjalan"</string>
    <string name="tare_job_min_start" msgid="6508233901992538188">"Tugas Prioritas Minimum Dimulai"</string>
    <string name="tare_job_min_running" msgid="6167128996320622604">"Tugas Prioritas Minimum Berjalan"</string>
    <string name="tare_job_timeout_penalty" msgid="7644332836795492506">"Penalti Waktu Tunggu Tugas"</string>
    <string name="tare_min_balance_exempted" msgid="6693710075762973485">"Saldo Minimum saat Penuh (Dikecualikan)"</string>
    <string name="tare_min_balance_headless_app" msgid="6906353766678577244">"Saldo Minimum saat Penuh (Aplikasi Sistem Headless)"</string>
    <string name="tare_min_balance_other_app" msgid="3404774196832506476">"Saldo Minimum saat Penuh (Aplikasi yang Tersisa)"</string>
    <string name="tare_min_balance_addition_app_updater" msgid="5391956072471201269">"Penambahan Saldo Minimum saat Penuh (Alat Update Aplikasi)"</string>
  <string-array name="tare_modifiers_subfactors">
    <item msgid="3325940509857535498">"Mengisi daya"</item>
    <item msgid="658627268149681677">"Istirahatkan"</item>
    <item msgid="1599558140284643834">"Mode Hemat Daya"</item>
    <item msgid="588427840913221601">"Status Proses"</item>
  </string-array>
    <string name="tare_dialog_confirm_button_title" msgid="9179397559760203348">"Konfirmasi"</string>
    <string name="dream_preview_button_title" msgid="6637456541851795952">"Pratinjau"</string>
    <string name="dream_picker_category" msgid="7726447836872744867">"Pilih screensaver"</string>
    <string name="dream_complications_toggle_title" msgid="4273232303027449163">"Tampilkan informasi tambahan"</string>
    <string name="dream_complications_toggle_summary" msgid="8088911054987524904">"Tampilkan berbagai informasi seperti waktu, cuaca, dan lain-lain di screensaver"</string>
    <string name="dream_home_controls_toggle_title" msgid="706799741564479248">"Tampilkan kontrol rumah"</string>
    <string name="dream_home_controls_toggle_summary" msgid="4102519907917430579">"Tampilkan tombol kontrol rumah di screensaver"</string>
    <string name="dream_more_settings_category" msgid="3119192146760773748">"Setelan lainnya"</string>
    <string name="dream_setup_title" msgid="2458303874255396142">"Pilih screensaver"</string>
    <string name="dream_setup_description" msgid="7508547154038580296">"Pilih screensaver yang akan ditampilkan di layar saat tablet dipasang ke dok. Perangkat Anda mungkin menggunakan lebih banyak daya saat screensaver digunakan."</string>
    <string name="customize_button_title" msgid="1110284655990203359">"Sesuaikan"</string>
    <string name="customize_button_description" msgid="7440248477266126231">"Sesuaikan <xliff:g id="SCREENSAVER_NAME">%1$s</xliff:g>"</string>
    <string name="reboot_dialog_enable_freeform_support" msgid="6412591361284929149">"Perlu memulai ulang untuk mengaktifkan dukungan bentuk bebas."</string>
    <string name="reboot_dialog_force_desktop_mode" msgid="2021839270403432948">"Perlu memulai ulang untuk memaksa mode desktop di layar sekunder."</string>
    <string name="reboot_dialog_reboot_now" msgid="235616015988522355">"Mulai ulang sekarang"</string>
    <string name="reboot_dialog_reboot_later" msgid="4261717094186904568">"Mulai ulang nanti"</string>
    <string name="bluetooth_details_spatial_audio_title" msgid="1368071116994002707">"Audio Spasial"</string>
    <string name="bluetooth_details_spatial_audio_summary" msgid="5026859623681482668">"Audio dari perangkat media yang kompatibel menjadi lebih imersif"</string>
    <string name="bluetooth_details_head_tracking_title" msgid="5416972521040337799">"Pelacakan gerak kepala"</string>
    <string name="bluetooth_details_head_tracking_summary" msgid="3942238746595985395">"Audio akan berubah saat Anda menggerakkan kepala agar terdengar lebih alami"</string>
    <string name="ingress_rate_limit_title" msgid="2106694002836274350">"Batas kecepatan download jaringan"</string>
    <string name="ingress_rate_limit_summary" msgid="1097811019742438371">"Konfigurasi batas kecepatan masuk bandwidth jaringan yang diterapkan ke semua jaringan yang menyediakan koneksi internet."</string>
    <string name="ingress_rate_limit_dialog_title" msgid="5359461052422633789">"Konfigurasi batas kecepatan download jaringan"</string>
    <string name="ingress_rate_limit_no_limit_entry" msgid="8741098826008012163">"Tak terbatas"</string>
    <string name="disable_phantom_process_monitor_title" msgid="8348108346706188771">"Nonaktifkan batasan proses turunan"</string>
    <string name="disable_phantom_process_monitor_summary" msgid="3044464635550256985">"Nonaktifkan batasan penggunaan resource sistem pada proses turunan aplikasi"</string>
    <string name="enable_notes_role_title" msgid="7662702013496114763">"Aktifkan paksa peran Catatan"</string>
    <string name="enable_notes_role_summary" msgid="136916915155048249">"Aktifkan integrasi sistem pembuatan catatan melalui peran Catatan. Jika peran Catatan telah diaktifkan, setelan ini tidak melakukan apa pun."</string>
    <string name="bluetooth_broadcast_dialog_title" msgid="9172775308463135884">"Siaran"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_app" msgid="1016617579194329005">"Siarkan <xliff:g id="CURRENTAPP">%1$s</xliff:g>"</string>
    <string name="bluetooth_broadcast_dialog_find_message" msgid="6621660851669953883">"Dengarkan siaran yang diputar di dekat Anda"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_message" msgid="6198264676009094495">"Siarkan media ke perangkat di dekat Anda, atau dengarkan siaran orang lain"</string>
    <string name="bluetooth_find_broadcast_title" msgid="5385985218699831970">"Siaran"</string>
    <string name="bluetooth_find_broadcast_summary" msgid="3907899428626210673">"Mendengarkan"</string>
    <string name="bluetooth_find_broadcast" msgid="1768337775649457586">"Temukan siaran"</string>
    <string name="bluetooth_find_broadcast_button_leave" msgid="7881206581147104908">"Keluar dari siaran"</string>
    <string name="bluetooth_find_broadcast_button_scan" msgid="3995664694641895189">"Pindai kode QR"</string>
    <string name="find_broadcast_password_dialog_title" msgid="3176988702535737484">"Masukkan sandi"</string>
    <string name="find_broadcast_password_dialog_connection_error" msgid="47873617983439400">"Tidak dapat terhubung. Coba lagi."</string>
    <string name="find_broadcast_password_dialog_password_error" msgid="243855327674765">"Sandi salah"</string>
    <string name="find_broadcast_join_broadcast_error" msgid="5486980388774711346">"Tidak dapat bergabung ke siaran"</string>
    <string name="bt_le_audio_scan_qr_code_scanner" msgid="7614569515419813053">"Untuk mulai mendengarkan, pusatkan kode QR di bawah"</string>
    <string name="bt_le_audio_qr_code_is_not_valid_format" msgid="7821837654128137901">"Format kode QR tidak valid"</string>
    <string name="convert_to_esim_title" msgid="71037864129009206">"Konversi ke eSIM"</string>
    <string name="transfer_esim_to_another_device_title" msgid="5286117866086383192">"Transfer eSIM ke perangkat lain"</string>
    <string name="background_install_preference_summary" msgid="3065219346519340364">"{count,plural, =1{# aplikasi}other{# aplikasi}}"</string>
    <string name="background_install_title" msgid="607913515188276168">"Aplikasi yang diinstal di latar belakang"</string>
    <string name="background_install_summary" msgid="3890296129543309666">"Produsen perangkat dapat menginstal aplikasi di perangkat Anda di latar belakang, atau mengizinkan operator dan partner lain melakukannya.\n\nSetiap aplikasi yang tercantum di sini tidak diperlukan oleh perangkat Anda untuk berfungsi sebagaimana mestinya. Anda dapat meng-uninstal aplikasi jika tidak menginginkannya."</string>
    <string name="background_install_feature_list_no_entry" msgid="2071343281272266154">"Tidak ada aplikasi yang diinstal di latar belakang"</string>
    <string name="background_install_uninstall_button_description" msgid="1189649052911501249">"Uninstal aplikasi"</string>
    <string name="background_install_before" msgid="8608614957688912715">"{count,plural, =1{Aplikasi yang diinstal dalam # bulan terakhir}other{Aplikasi yang diinstal dalam # bulan terakhir}}"</string>
    <string name="background_install_after" msgid="7983488897570908149">"{count,plural, =1{Aplikasi diinstal lebih dari # bulan lalu}other{Aplikasi diinstal lebih dari # bulan lalu}}"</string>
    <string name="accessibility_fingerprint_label" msgid="5017431423168191733">"Sensor sidik jari"</string>
    <string name="flash_notifications_title" msgid="4490438861180492311">"Notifikasi flash"</string>
    <string name="flash_notifications_about_title" msgid="9004351252928121214">"Tentang notifikasi flash"</string>
    <string name="flash_notifications_summary_off" msgid="6056282996770691461">"Nonaktif"</string>
    <string name="flash_notifications_summary_on_camera" msgid="3286405833586333730">"Aktif / Flash kamera"</string>
    <string name="flash_notifications_summary_on_screen" msgid="9040640799633336219">"Aktif / Flash layar"</string>
    <string name="flash_notifications_summary_on_camera_and_screen" msgid="2326268141063768701">"Aktif / Flash kamera dan layar"</string>
    <string name="flash_notifications_intro" msgid="8409873413480928249">"Aktifkan lampu flash kamera atau layar saat Anda menerima notifikasi atau saat alarm berbunyi"</string>
    <string name="flash_notifications_intro_without_camera_flash" msgid="6297337174487793891">"Aktifkan lampu flash layar saat Anda menerima notifikasi atau saat alarm berbunyi"</string>
    <string name="flash_notifications_note" msgid="2426125248448055075">"Gunakan notifikasi flash dengan hati-hati jika Anda sensitif terhadap cahaya"</string>
    <string name="flash_notifications_keywords" msgid="2458759275318514836">"flash, lampu, gangguan pendengaran, kerusakan pendengaran"</string>
    <string name="flash_notifications_preview" msgid="5320176885050440874">"Pratinjau"</string>
    <string name="camera_flash_notification_title" msgid="2475084876382922732">"Flash kamera"</string>
    <string name="screen_flash_notification_title" msgid="3773100725793316708">"Flash layar"</string>
    <string name="screen_flash_notification_color_title" msgid="7213407653340970790">"Warna flash layar"</string>
    <string name="screen_flash_color_blue" msgid="3585766657607931371">"Biru"</string>
    <string name="screen_flash_color_azure" msgid="8691198532944992243">"Biru langit"</string>
    <string name="screen_flash_color_cyan" msgid="6878780006173747267">"Sian"</string>
    <string name="screen_flash_color_spring_green" msgid="4466548514738457815">"Hijau suji"</string>
    <string name="screen_flash_color_green" msgid="8418019648507964564">"Hijau"</string>
    <string name="screen_flash_color_chartreuse_green" msgid="7456381649919010366">"Hijau belerang"</string>
    <string name="screen_flash_color_yellow" msgid="7413465411615454556">"Kuning"</string>
    <string name="screen_flash_color_orange" msgid="979177126315557656">"Oranye"</string>
    <string name="screen_flash_color_red" msgid="8954162219886445491">"Merah"</string>
    <string name="screen_flash_color_rose" msgid="1216848195972231251">"Merah mawar"</string>
    <string name="screen_flash_color_magenta" msgid="7726221666557102155">"Magenta"</string>
    <string name="screen_flash_color_violet" msgid="1279950780509029495">"Violet"</string>
    <string name="color_selector_dialog_done" msgid="121253968943363376">"Selesai"</string>
    <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Batal"</string>
    <string name="contrast_title" msgid="6885768151336508075">"Kontras"</string>
    <string name="contrast_standard" msgid="1097297089917185235">"Standar"</string>
    <string name="contrast_medium" msgid="384414510709285811">"Sedang"</string>
    <string name="contrast_high" msgid="3988567609694797696">"Tinggi"</string>
    <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Aplikasi ini hanya dapat dibuka di 1 jendela"</string>
</resources>
