<?xml version="1.0" encoding="UTF-8"?>
<!-- 
/* //device/apps/common/assets/res/any/strings.xml
**
** Copyright 2006, 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="byteShort" msgid="8340973892742019101">"B"</string>
    <string name="kilobyteShort" msgid="5973789783504771878">"KB"</string>
    <string name="megabyteShort" msgid="6355851576770428922">"MB"</string>
    <string name="gigabyteShort" msgid="3259882455212193214">"GB"</string>
    <string name="terabyteShort" msgid="231613018159186962">"TB"</string>
    <string name="petabyteShort" msgid="5637816680144990219">"PB"</string>
    <string name="fileSizeSuffix" msgid="9164292791500531949">"<xliff:g id="NUMBER">%1$s</xliff:g><xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="untitled" msgid="4638956954852782576">"&lt;Tanpa judul&gt;"</string>
    <string name="ellipsis" msgid="7899829516048813237">"…"</string>
    <string name="ellipsis_two_dots" msgid="1228078994866030736">"‥"</string>
    <string name="emptyPhoneNumber" msgid="7694063042079676517">"(Tidak ada nomor telepon)"</string>
    <string name="unknownName" msgid="2277556546742746522">"(Tidak diketahui)"</string>
    <string name="defaultVoiceMailAlphaTag" msgid="2660020990097733077">"Kotak Pesan"</string>
    <string name="defaultMsisdnAlphaTag" msgid="2850889754919584674">"MSISDN1"</string>
    <string name="mmiError" msgid="5154499457739052907">"Masalah sambungan atau kode MMI tidak valid."</string>
    <string name="mmiFdnError" msgid="5224398216385316471">"Operasi dibatasi untuk nomor panggilan tetap saja."</string>
    <string name="serviceEnabled" msgid="8147278346414714315">"Layanan telah diaktifkan."</string>
    <string name="serviceEnabledFor" msgid="6856228140453471041">"Layanan diaktifkan untuk:"</string>
    <string name="serviceDisabled" msgid="1937553226592516411">"Layanan telah dinonaktifkan."</string>
    <string name="serviceRegistered" msgid="6275019082598102493">"Pendaftaran berhasil."</string>
    <string name="serviceErased" msgid="1288584695297200972">"Penghapusan berhasil."</string>
    <string name="passwordIncorrect" msgid="7612208839450128715">"Sandi salah."</string>
    <string name="mmiComplete" msgid="8232527495411698359">"MMI selesai."</string>
    <string name="badPin" msgid="9015277645546710014">"PIN lama yang Anda ketikkan salah."</string>
    <string name="badPuk" msgid="5487257647081132201">"PUK yang Anda ketikkan salah."</string>
    <string name="mismatchPin" msgid="609379054496863419">"PIN yang Anda ketik tidak cocok."</string>
    <string name="invalidPin" msgid="3850018445187475377">"Ketikkan PIN berupa 4 sampai 8 angka."</string>
    <string name="invalidPuk" msgid="8761456210898036513">"Ketik PUK yang terdiri dari 8 angka atau lebih."</string>
    <string name="needPuk" msgid="919668385956251611">"Kartu SIM Anda dikunci PUK. Ketikkan kode PUK untuk membukanya."</string>
    <string name="needPuk2" msgid="4526033371987193070">"Ketikkan PUK2 untuk membuka kartu SIM"</string>
    <string name="imei" msgid="2625429890869005782">"IMEI"</string>
    <string name="meid" msgid="4841221237681254195">"MEID"</string>
    <string name="ClipMmi" msgid="6952821216480289285">"Nomor Penelepon Masuk"</string>
    <string name="ClirMmi" msgid="7784673673446833091">"Nomor Penelepon Keluar"</string>
    <string name="CfMmi" msgid="5123218989141573515">"Penerusan panggilan"</string>
    <string name="CwMmi" msgid="9129678056795016867">"Nada tunggu"</string>
    <string name="BaMmi" msgid="455193067926770581">"Pemblokiran panggilan"</string>
    <string name="PwdMmi" msgid="7043715687905254199">"Sandi berubah"</string>
    <string name="PinMmi" msgid="3113117780361190304">"ubah PIN"</string>
    <string name="CnipMmi" msgid="3110534680557857162">"Memanggil nomor yang ada"</string>
    <string name="CnirMmi" msgid="3062102121430548731">"Nomor panggilan dibatasi"</string>
    <string name="ThreeWCMmi" msgid="9051047170321190368">"Panggilan bertiga"</string>
    <string name="RuacMmi" msgid="7827887459138308886">"Penolakan panggilan yang tidak diinginkan"</string>
    <string name="CndMmi" msgid="3116446237081575808">"Pengiriman nomor panggilan"</string>
    <string name="DndMmi" msgid="1265478932418334331">"Jangan ganggu"</string>
    <string name="CLIRDefaultOnNextCallOn" msgid="429415409145781923">"Nomor penelepon default \"dibatasi\". Panggilan selanjutnya: Dibatasi"</string>
    <string name="CLIRDefaultOnNextCallOff" msgid="3092918006077864624">"Nomor pengguna default \"dibatasi\". Panggilan selanjutnya: Tidak dibatasi."</string>
    <string name="CLIRDefaultOffNextCallOn" msgid="6179425182856418465">"Nomor penelepon default tidak dibatasi. Panggilan selanjutnya: Dibatasi"</string>
    <string name="CLIRDefaultOffNextCallOff" msgid="2567998633124408552">"Nomor penelepon default tidak dibatasi. Panggilan selanjutnya: Tidak dibatasi"</string>
    <string name="serviceNotProvisioned" msgid="8614830180508686666">"Layanan tidak diperlengkapi."</string>
    <string name="CLIRPermanent" msgid="3377371145926835671">"Anda tidak dapat mengubah setelan nomor penelepon."</string>
    <string name="RestrictedChangedTitle" msgid="5592189398956187498">"Akses terbatas berubah"</string>
    <string name="RestrictedOnData" msgid="8653794784690065540">"Layanan data dicekal."</string>
    <string name="RestrictedOnEmergency" msgid="6581163779072833665">"Layanan darurat dicekal."</string>
    <string name="RestrictedOnNormal" msgid="4953867011389750673">"Layanan suara dicekal."</string>
    <string name="RestrictedOnAllVoice" msgid="3396963652108151260">"Semua layanan suara dicekal."</string>
    <string name="RestrictedOnSms" msgid="8314352327461638897">"Layanan SMS dicekal."</string>
    <string name="RestrictedOnVoiceData" msgid="996636487106171320">"Layanan suara/data dicekal."</string>
    <string name="RestrictedOnVoiceSms" msgid="1888588152792023873">"Layanan suara/SMS dicekal."</string>
    <string name="RestrictedOnAll" msgid="5643028264466092821">"Semua layanan suara/data/SMS dicekal."</string>
    <string name="serviceClassVoice" msgid="1258393812335258019">"Voice"</string>
    <string name="serviceClassData" msgid="872456782077937893">"Data"</string>
    <string name="serviceClassFAX" msgid="5566624998840486475">"FAKS"</string>
    <string name="serviceClassSMS" msgid="2015460373701527489">"SMS"</string>
    <string name="serviceClassDataAsync" msgid="4523454783498551468">"Tidak sinkron"</string>
    <string name="serviceClassDataSync" msgid="7530000519646054776">"Sinkron"</string>
    <string name="serviceClassPacket" msgid="6991006557993423453">"Paket"</string>
    <string name="serviceClassPAD" msgid="3235259085648271037">"PAD"</string>
    <string name="roamingText0" msgid="7170335472198694945">"Indikator Jelajah Hidup"</string>
    <string name="roamingText1" msgid="5314861519752538922">"Indikator Jelajah Mati"</string>
    <string name="roamingText2" msgid="8969929049081268115">"Indikator Jelajah Berpendar"</string>
    <string name="roamingText3" msgid="5148255027043943317">"Keluar dari Lingkungan"</string>
    <string name="roamingText4" msgid="8808456682550796530">"Keluar dari Bangunan"</string>
    <string name="roamingText5" msgid="7604063252850354350">"Roaming - Sistem Yang Dipilih"</string>
    <string name="roamingText6" msgid="2059440825782871513">"Roaming - Sistem Tersedia"</string>
    <string name="roamingText7" msgid="7112078724097233605">"Mitra Roaming - Alliance"</string>
    <string name="roamingText8" msgid="5989569778604089291">"Roaming - Mitra Premium"</string>
    <string name="roamingText9" msgid="7969296811355152491">"Fungsionalitas Layanan Roaming - Penuh"</string>
    <string name="roamingText10" msgid="3992906999815316417">"Fungsionalitas Layanan Roaming - Sebagian"</string>
    <string name="roamingText11" msgid="4154476854426920970">"Spanduk Roaming Hidup"</string>
    <string name="roamingText12" msgid="1189071119992726320">"Spanduk Roaming Mati"</string>
    <string name="roamingTextSearching" msgid="8360141885972279963">"Mencari layanan"</string>
    <string name="cfTemplateNotForwarded" msgid="1683685883841272560">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: Tidak diteruskan"</string>
    <string name="cfTemplateForwarded" msgid="1302922117498590521">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: <xliff:g id="DIALING_NUMBER">{1}</xliff:g>"</string>
    <string name="cfTemplateForwardedTime" msgid="9206251736527085256">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: <xliff:g id="DIALING_NUMBER">{1}</xliff:g> setelah <xliff:g id="TIME_DELAY">{2}</xliff:g> detik"</string>
    <string name="cfTemplateRegistered" msgid="5073237827620166285">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: Tidak diteruskan"</string>
    <string name="cfTemplateRegisteredTime" msgid="6781621964320635172">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: Tidak diteruskan"</string>
    <string name="fcComplete" msgid="3118848230966886575">"Kode fitur selesai."</string>
    <string name="fcError" msgid="3327560126588500777">"Masalah sambungan atau kode fitur tidak valid."</string>
    <string name="httpErrorOk" msgid="1191919378083472204">"Oke"</string>
    <string name="httpError" msgid="7956392511146698522">"Terjadi kesalahan jaringan."</string>
    <string name="httpErrorLookup" msgid="4711687456111963163">"Tidak dapat menemukan URL."</string>
    <string name="httpErrorUnsupportedAuthScheme" msgid="6299980280442076799">"Skema autentikasi situs tidak didukung."</string>
    <string name="httpErrorAuth" msgid="1435065629438044534">"Tidak dapat mengautentikasi."</string>
    <string name="httpErrorProxyAuth" msgid="1788207010559081331">"Autentikasi via proxy server gagal."</string>
    <string name="httpErrorConnect" msgid="8714273236364640549">"Tidak dapat tersambung ke server."</string>
    <string name="httpErrorIO" msgid="2340558197489302188">"Tidak dapat berkomunikasi dengan server. Coba lagi nanti."</string>
    <string name="httpErrorTimeout" msgid="4743403703762883954">"Sambungan ke server terputus."</string>
    <string name="httpErrorRedirectLoop" msgid="8679596090392779516">"Laman ini berisi terlalu banyak pengalihan server."</string>
    <string name="httpErrorUnsupportedScheme" msgid="5015730812906192208">"Protokol tidak didukung."</string>
    <string name="httpErrorFailedSslHandshake" msgid="96549606000658641">"Tidak dapat membuat sambungan aman."</string>
    <string name="httpErrorBadUrl" msgid="3636929722728881972">"Tidak dapat membuka laman karena URL tidak valid."</string>
    <string name="httpErrorFile" msgid="2170788515052558676">"Tidak dapat mengakses file."</string>
    <string name="httpErrorFileNotFound" msgid="6203856612042655084">"Tidak dapat menemukan file yang diminta."</string>
    <string name="httpErrorTooManyRequests" msgid="1235396927087188253">"Terlalu banyak permintaan yang diproses. Coba lagi nanti."</string>
    <string name="notification_title" msgid="8967710025036163822">"Kesalahan saat masuk untuk <xliff:g id="ACCOUNT">%1$s</xliff:g>"</string>
    <string name="contentServiceSync" msgid="8353523060269335667">"Sinkron"</string>
    <string name="contentServiceSyncNotificationTitle" msgid="397743349191901458">"Sinkron"</string>
    <string name="contentServiceTooManyDeletesNotificationDesc" msgid="8100981435080696431">"Terlalu banyak <xliff:g id="CONTENT_TYPE">%s</xliff:g> penghapusan."</string>
    <string name="low_memory" product="tablet" msgid="6494019234102154896">"Penyimpanan tablet penuh. Hapus beberapa file untuk mengosongkan ruang."</string>
    <string name="low_memory" product="default" msgid="3475999286680000541">"Penyimpanan di ponsel penuh. Hapus sebagian file untuk mengosongkan ruang."</string>
    <string name="me" msgid="6545696007631404292">"Saya"</string>
    <string name="power_dialog" product="tablet" msgid="8545351420865202853">"Opsi tablet"</string>
    <string name="power_dialog" product="default" msgid="1319919075463988638">"Opsi telepon"</string>
    <string name="silent_mode" msgid="7167703389802618663">"Modus senyap"</string>
    <string name="turn_on_radio" msgid="3912793092339962371">"Hidupkan nirkabel"</string>
    <string name="turn_off_radio" msgid="8198784949987062346">"Matikan nirkabel"</string>
    <string name="screen_lock" msgid="799094655496098153">"Kunci layar"</string>
    <string name="power_off" msgid="4266614107412865048">"Matikan daya"</string>
    <string name="silent_mode_silent" msgid="319298163018473078">"Pendering mati"</string>
    <string name="silent_mode_vibrate" msgid="7072043388581551395">"Pendering bergetar"</string>
    <string name="silent_mode_ring" msgid="8592241816194074353">"Pendering nyala"</string>
    <string name="shutdown_progress" msgid="2281079257329981203">"Sedang mematikan..."</string>
    <string name="shutdown_confirm" product="tablet" msgid="3385745179555731470">"Tablet Anda akan dimatikan."</string>
    <string name="shutdown_confirm" product="default" msgid="649792175242821353">"Ponsel Anda akan dimatikan."</string>
    <string name="shutdown_confirm_question" msgid="2906544768881136183">"Anda ingin mematikannya?"</string>
    <string name="reboot_safemode_title" msgid="7054509914500140361">"Reboot ke mode aman"</string>
    <string name="reboot_safemode_confirm" msgid="55293944502784668">"Apakah Anda ingin reboot ke mode aman? Tindakan ini akan menonaktifkan semua aplikasi pihak ketiga yang telah dipasang. Aplikasi tersebut akan dipulihkan ketika Anda melakukan reboot lagi."</string>
    <string name="recent_tasks_title" msgid="3691764623638127888">"Terbaru"</string>
    <string name="no_recent_tasks" msgid="8794906658732193473">"Tidak ada apl terbaru."</string>
    <string name="global_actions" product="tablet" msgid="408477140088053665">"Opsi tablet"</string>
    <string name="global_actions" product="default" msgid="2406416831541615258">"Opsi telepon"</string>
    <string name="global_action_lock" msgid="2844945191792119712">"Kunci layar"</string>
    <string name="global_action_power_off" msgid="4471879440839879722">"Matikan daya"</string>
    <string name="global_action_toggle_silent_mode" msgid="8219525344246810925">"Mode senyap"</string>
    <string name="global_action_silent_mode_on_status" msgid="3289841937003758806">"Suara MATI"</string>
    <string name="global_action_silent_mode_off_status" msgid="1506046579177066419">"Suara HIDUP"</string>
    <string name="global_actions_toggle_airplane_mode" msgid="5884330306926307456">"Mode pesawat"</string>
    <string name="global_actions_airplane_mode_on_status" msgid="2719557982608919750">"Mode pesawat HIDUP"</string>
    <string name="global_actions_airplane_mode_off_status" msgid="5075070442854490296">"Mode pesawat MATI"</string>
    <string name="status_bar_notification_info_overflow" msgid="5301981741705354993">"999+"</string>
    <string name="safeMode" msgid="2788228061547930246">"Mode aman"</string>
    <string name="android_system_label" msgid="6577375335728551336">"Sistem Android"</string>
    <string name="permgrouplab_costMoney" msgid="5429808217861460401">"Layanan berbayar"</string>
    <string name="permgroupdesc_costMoney" msgid="3293301903409869495">"Lakukan hal yang dapat dikenai biaya."</string>
    <string name="permgrouplab_messages" msgid="7521249148445456662">"Pesan Anda"</string>
    <string name="permgroupdesc_messages" msgid="7821999071003699236">"Membaca dan menulis SMS, email, dan pesan Anda lainnya."</string>
    <string name="permgrouplab_personalInfo" msgid="3519163141070533474">"Informasi pribadi Anda"</string>
    <string name="permgroupdesc_personalInfo" product="tablet" msgid="6975389054186265786">"Akses langsung ke kontak dan kalender yang disimpan di tablet."</string>
    <string name="permgroupdesc_personalInfo" product="default" msgid="5488050357388806068">"akses langsung pada kontak dan kalender yang tersimpan pada ponsel."</string>
    <string name="permgrouplab_location" msgid="635149742436692049">"Lokasi Anda"</string>
    <string name="permgroupdesc_location" msgid="5704679763124170100">"Memonitor lokasi fisik Anda."</string>
    <string name="permgrouplab_network" msgid="5808983377727109831">"Komunikasi jaringan"</string>
    <string name="permgroupdesc_network" msgid="4478299413241861987">"Mengakses berbagai fitur jaringan."</string>
    <string name="permgrouplab_accounts" msgid="3359646291125325519">"Akun-akun Anda"</string>
    <string name="permgroupdesc_accounts" msgid="4948732641827091312">"Akses akun yang tersedia."</string>
    <string name="permgrouplab_hardwareControls" msgid="7998214968791599326">"Kontrol perangkat keras"</string>
    <string name="permgroupdesc_hardwareControls" msgid="4357057861225462702">"Akses langsung ke perangkat keras pada handset."</string>
    <string name="permgrouplab_phoneCalls" msgid="9067173988325865923">"Panggilan telepon"</string>
    <string name="permgroupdesc_phoneCalls" msgid="7489701620446183770">"Monitor, rekam, dan proses panggilan telepon."</string>
    <string name="permgrouplab_systemTools" msgid="4652191644082714048">"Alat sistem"</string>
    <string name="permgroupdesc_systemTools" msgid="8162102602190734305">"Akses tingkat rendah dan kontrol sistem."</string>
    <string name="permgrouplab_developmentTools" msgid="3446164584710596513">"Peralatan pengembangan"</string>
    <string name="permgroupdesc_developmentTools" msgid="7058828032358142018">"Fitur hanya diperlukan oleh pengembang apl."</string>
    <string name="permgrouplab_storage" msgid="1971118770546336966">"Penyimpanan"</string>
    <string name="permgroupdesc_storage" product="nosdcard" msgid="7442318502446874999">"Akses penyimpanan USB."</string>
    <string name="permgroupdesc_storage" product="default" msgid="9203302214915355774">"Akses kartu SD."</string>
    <string name="permlab_statusBar" msgid="7417192629601890791">"nonaktifkan atau ubah bilah status"</string>
    <string name="permdesc_statusBar" msgid="8434669549504290975">"Mengizinkan apl menonaktifkan bilah status atau menambah dan menghapus ikon sistem."</string>
    <string name="permlab_statusBarService" msgid="7247281911387931485">"bilah status"</string>
    <string name="permdesc_statusBarService" msgid="716113660795976060">"Mengizinkan apl menjadi bilah status."</string>
    <string name="permlab_expandStatusBar" msgid="1148198785937489264">"luaskan/ciutkan bilah status"</string>
    <string name="permdesc_expandStatusBar" msgid="6917549437129401132">"Mengizinkan apl memperluas atau menciutkan bilah status."</string>
    <string name="permlab_processOutgoingCalls" msgid="3906007831192990946">"ubah rute panggilan keluar"</string>
    <string name="permdesc_processOutgoingCalls" msgid="5331318931937402040">"Memungkinkan aplikasi memproses panggilan keluar dan mengubah nomor yang akan dipanggil. Izin ini memungkinkan aplikasi memantau, mengalihkan, atau mencegah panggilan keluar."</string>
    <string name="permlab_receiveSms" msgid="8673471768947895082">"terima pesan teks (SMS)"</string>
    <string name="permdesc_receiveSms" msgid="6424387754228766939">"Memungkinkan aplikasi menerima dan memproses pesan SMS. Ini artinya aplikasi dapat memantau atau menghapus pesan yang dikirim ke perangkat Anda tanpa menunjukkannya kepada Anda."</string>
    <string name="permlab_receiveMms" msgid="1821317344668257098">"terima pesan teks (MMS)"</string>
    <string name="permdesc_receiveMms" msgid="533019437263212260">"Memungkinkan aplikasi menerima dan memproses pesan MMS. Ini artinya aplikasi dapat memantau atau menghapus pesan yang dikirim ke perangkat Anda tanpa menunjukkannya kepada Anda."</string>
    <string name="permlab_receiveEmergencyBroadcast" msgid="1803477660846288089">"terima siaran darurat"</string>
    <string name="permdesc_receiveEmergencyBroadcast" msgid="848524070262431974">"Mengizinkan apl menerima dan memproses pesan siaran darurat. Izin ini hanya tersedia untuk apl sistem."</string>
    <string name="permlab_readCellBroadcasts" msgid="1598328843619646166">"membaca pesan siaran seluler"</string>
    <string name="permdesc_readCellBroadcasts" msgid="6361972776080458979">"Mengizinkan aplikasi membaca pesan siaran seluler yang diterima perangkat Anda. Lansiran siaran seluler dikirimkan di beberapa lokasi untuk memperingatkan Anda tentang situasi darurat. Aplikasi berbahaya dapat mengganggu kinerja atau operasi perangkat Anda saat siaran seluler darurat diterima."</string>
    <string name="permlab_sendSms" msgid="5600830612147671529">"kirim pesan SMS"</string>
    <string name="permdesc_sendSms" msgid="7094729298204937667">"Memungkinkan aplikasi mengirim pesan SMS. Izin ini dapat mengakibatkan biaya tak terduga. Aplikasi berbahaya dapat membebankan biaya kepada Anda dengan mengirim pesan tanpa konfirmasi dari Anda."</string>
    <string name="permlab_sendSmsNoConfirmation" msgid="4781483105951730228">"mengirim SMS tanpa konfirmasi"</string>
    <string name="permdesc_sendSmsNoConfirmation" msgid="402569800862935907">"Memungkinkan aplikasi mengirim pesan SMS. Izin ini dapat mengakibatkan biaya tak terduga. Aplikasi berbahaya dapat membebankan biaya kepada Anda dengan mengirim pesan tanpa konfirmasi dari Anda."</string>
    <string name="permlab_readSms" msgid="8745086572213270480">"membaca pesan teks (SMS atau MMS) Anda"</string>
    <string name="permdesc_readSms" product="tablet" msgid="2467981548684735522">"Memungkinkan aplikasi membaca pesan SMS yang tersimpan di tablet atau kartu SIM Anda. Izin ini memungkinkan aplikasi membaca semua pesan SMS, terlepas dari konten atau kerahasiaan."</string>
    <string name="permdesc_readSms" product="default" msgid="3695967533457240550">"Memungkinkan aplikasi membaca pesan SMS yang tersimpan di ponsel atau kartu SIM Anda. Izin ini memungkinkan aplikasi membaca semua pesan SMS, terlepas dari konten atau kerahasiaan."</string>
    <string name="permlab_writeSms" msgid="3216950472636214774">"edit pesan teks (SMS atau MMS) Anda"</string>
    <string name="permdesc_writeSms" product="tablet" msgid="5160413947794501538">"Mengizinkan apl menulis ke pesan SMS yang tersimpan di tablet atau kartu SIM. Apl berbahaya dapat menghapus pesan Anda."</string>
    <string name="permdesc_writeSms" product="default" msgid="7268668709052328567">"Mengizinkan apl menulis ke pesan SMS yang tersimpan di ponsel atau kartu SIM. Apl berbahaya dapat menghapus pesan Anda."</string>
    <string name="permlab_receiveWapPush" msgid="5991398711936590410">"terima pesan teks (WAP)"</string>
    <string name="permdesc_receiveWapPush" msgid="748232190220583385">"Memungkinkan aplikasi menerima dan memproses pesan WAP. Izin ini mencakup kemampuan untuk memantau atau menghapus pesan yang dikirim kepada Anda tanpa menunjukkannya kepada Anda."</string>
    <string name="permlab_getTasks" msgid="6466095396623933906">"mengambil apl yang berjalan"</string>
    <string name="permdesc_getTasks" msgid="7454215995847658102">"Memungkinkan aplikasi mengambil informasi tentang tugas yang dijalankan saat ini dan baru-baru ini. Izin ini memungkinkan aplikasi menemukan informasi tentang aplikasi mana yang digunakan pada perangkat."</string>
    <string name="permlab_getDetailedTasks" msgid="6229468674753529501">"mengambil detail aplikasi yang sedang berjalan"</string>
    <string name="permdesc_getDetailedTasks" msgid="153824741440717599">"Izinkan aplikasi mengambil informasi mendetail tentang tugas yang saat ini dan baru-baru ini dijalankan. Aplikasi berbahaya dapat menemukan informasi pribadi tentang aplikasi lain."</string>
    <string name="permlab_reorderTasks" msgid="2018575526934422779">"menyusun ulang apl yang berjalan"</string>
    <string name="permdesc_reorderTasks" msgid="7734217754877439351">"Memungkinkan aplikasi memindah tugas ke latar depan dan latar belakang. Aplikasi dapat melakukannya tanpa masukan dari Anda."</string>
    <string name="permlab_removeTasks" msgid="6821513401870377403">"menghentikan apl yang berjalan"</string>
    <string name="permdesc_removeTasks" msgid="1394714352062635493">"Memungkinkan apl menghapus tugas dan menutup aplikasinya. Apl berbahaya dapat mengganggu perilaku apl lain."</string>
    <string name="permlab_startAnyActivity" msgid="2918768238045206456">"memulai aktivitas apa pun"</string>
    <string name="permdesc_startAnyActivity" msgid="997823695343584001">"Mengizinkan aplikasi memulai aktivitas apa pun, terlepas dari perlindungan izin atau status yang diekspor."</string>
    <string name="permlab_setScreenCompatibility" msgid="6975387118861842061">"menyetel kompatibilitas layar"</string>
    <string name="permdesc_setScreenCompatibility" msgid="692043618693917374">"Memungkinkan apl mengontrol mode kompatibilitas layar aplikasi lain. Aplikasi berbahaya dapat merusak perilaku aplikasi lain."</string>
    <string name="permlab_setDebugApp" msgid="3022107198686584052">"mengaktifkan debugging apl"</string>
    <string name="permdesc_setDebugApp" msgid="4474512416299013256">"Mengizinkan apl mengaktifkan debugging untuk apl lain. Apl berbahaya dapat menggunakan cara ini untuk menutup apl lain."</string>
    <string name="permlab_changeConfiguration" msgid="4162092185124234480">"ubah setelan tampilan sistem"</string>
    <string name="permdesc_changeConfiguration" msgid="4372223873154296076">"Mengizinkan apl mengubah konfigurasi saat ini, misalnya lokal atau ukuran font keseluruhan."</string>
    <string name="permlab_enableCarMode" msgid="5684504058192921098">"aktifkan mode mobil"</string>
    <string name="permdesc_enableCarMode" msgid="4853187425751419467">"Mengizinkan apl mengaktifkan mode mobil."</string>
    <string name="permlab_killBackgroundProcesses" msgid="3914026687420177202">"tutup aplikasi lainnya"</string>
    <string name="permdesc_killBackgroundProcesses" msgid="4593353235959733119">"Memungkinkan aplikasi mengakhiri proses latar belakang aplikasi lain. Izin ini dapat menyebabkan aplikasi lain berhenti berjalan."</string>
    <string name="permlab_forceStopPackages" msgid="2329627428832067700">"memaksa apl lain berhenti"</string>
    <string name="permdesc_forceStopPackages" msgid="5253157296183940812">"Mengizinkan apl menghentikan apl lain dengan paksa."</string>
    <string name="permlab_forceBack" msgid="652935204072584616">"memaksa apl untuk menutup"</string>
    <string name="permdesc_forceBack" msgid="3892295830419513623">"Mengizinkan apl menutup paksa kegiatan apa pun yang ada di latar depan dan kembali. Tidak pernah diperlukan oleh apl normal."</string>
    <string name="permlab_dump" msgid="1681799862438954752">"ambil kondisi internal sistem"</string>
    <string name="permdesc_dump" msgid="1778299088692290329">"Mengizinkan apl mengambil keadaan internal sistem. Apl berbahaya dapat mengambil berbagai informasi pribadi dan aman yang seharusnya tidak diperlukan."</string>
    <string name="permlab_retrieve_window_content" msgid="8022588608994589938">"ambil konten layar"</string>
    <string name="permdesc_retrieve_window_content" msgid="3193269069469700265">"Mengizinkan apl mengambil konten jendela aktif. Apl berbahaya dapat mengambil seluruh konten jendela dan memeriksa semua teksnya kecuali sandi."</string>
    <string name="permlab_shutdown" msgid="7185747824038909016">"penghentian sebagian"</string>
    <string name="permdesc_shutdown" msgid="7046500838746291775">"Letakkan pengelola aktivitas dalam kondisi mati. Tidak melakukan penonaktifan penuh."</string>
    <string name="permlab_stopAppSwitches" msgid="4138608610717425573">"cegah pergantian aplikasi"</string>
    <string name="permdesc_stopAppSwitches" msgid="8262195802582255021">"Mencegah pengguna beralih ke apl lain."</string>
    <string name="permlab_runSetActivityWatcher" msgid="892239094867182656">"memantau dan mengontrol semua peluncuran apl"</string>
    <string name="permdesc_runSetActivityWatcher" msgid="6003603162578577406">"Mengizinkan apl memantau dan mengontrol cara sistem meluncurkan kegiatan. Apl berbahaya dapat meretas sistem sepenuhnya. Izin ini hanya diperlukan untuk pengembangan, tidak pernah diperlukan untuk penggunaan normal."</string>
    <string name="permlab_broadcastPackageRemoved" msgid="2576333434893532475">"kirim siaran paket dihapus"</string>
    <string name="permdesc_broadcastPackageRemoved" msgid="6621901216207931089">"Mengizinkan apl menyiarkan pemberitahuan bahwa paket apl telah dihapus. Apl berbahaya dapat menggunakan ini untuk menutup apl lain yang berjalan."</string>
    <string name="permlab_broadcastSmsReceived" msgid="5689095009030336593">"kirim siaran SMS-diterima"</string>
    <string name="permdesc_broadcastSmsReceived" msgid="4152037720034365492">"Mengizinkan apl menyiarkan pemberitahuan bahwa pesan SMS telah diterima. Apl berbahaya dapat menggunakan ini untuk memalsukan pesan SMS masuk."</string>
    <string name="permlab_broadcastWapPush" msgid="3145347413028582371">"kirim siaran WAP-PUSH-diterima"</string>
    <string name="permdesc_broadcastWapPush" msgid="4783402525039442729">"Mengizinkan apl menyiarkan pemberitahuan bahwa pesan WAP PUSH telah diterima. Apl berbahaya dapat menggunakan ini untuk memalsukan penerimaan pesan MMS atau diam-diam mengganti konten laman web apa pun dengan varian berbahaya."</string>
    <string name="permlab_setProcessLimit" msgid="2451873664363662666">"batasi jumlah dari proses yang berjalan"</string>
    <string name="permdesc_setProcessLimit" msgid="7318061314040879542">"Mengizinkan apl mengontrol jumlah maksimum proses yang akan berjalan. Tidak pernah diperlukan oleh apl normal."</string>
    <string name="permlab_setAlwaysFinish" msgid="550958507798796965">"paksa aplikasi latar belakang agar menutup"</string>
    <string name="permdesc_setAlwaysFinish" msgid="7471310652868841499">"Mengizinkan apl mengontrol apakah aktivitas selalu selesai setelah berpindah ke latar belakang. Tidak pernah digunakan untuk apl normal."</string>
    <string name="permlab_batteryStats" msgid="7863923071360031652">"ubah statistika baterai"</string>
    <string name="permdesc_batteryStats" msgid="6835186932305744068">"Mengizinkan apl memodifikasi statistik baterai yang dikumpulkan. Tidak untuk digunakan oleh apl normal."</string>
    <string name="permlab_backup" msgid="470013022865453920">"mengontrol cadangan dan pemulihan sistem"</string>
    <string name="permdesc_backup" msgid="6912230525140589891">"Mengizinkan apl mengontrol mekanisme pencadangan dan pemulihan sistem. Tidak untuk digunakan oleh apl normal."</string>
    <string name="permlab_confirm_full_backup" msgid="5557071325804469102">"konfirmasi pencadangan penuh atau pulihkan operasi"</string>
    <string name="permdesc_confirm_full_backup" msgid="1748762171637699562">"Mengizinkan apl meluncurkan UI konfirmasi pencadangan penuh. Tidak untuk digunakan oleh apl apa pun."</string>
    <string name="permlab_internalSystemWindow" msgid="2148563628140193231">"tampilkan jendela yang tidak diizinkan"</string>
    <string name="permdesc_internalSystemWindow" msgid="7458387759461466397">"Mengizinkan apl membuat jendela agar dapat digunakan oleh antarmuka pengguna sistem internal. Tidak untuk digunakan oleh apl normal."</string>
    <string name="permlab_systemAlertWindow" msgid="3543347980839518613">"tutup aplikasi lain"</string>
    <string name="permdesc_systemAlertWindow" msgid="4460454022797261814">"Memungkinkan aplikasi menampilkan jendela lansiran sistem. Beberapa jendela lansiran dapat mengambil alih seluruh layar."</string>
    <string name="permlab_setAnimationScale" msgid="2805103241153907174">"ubah kecepatan animasi global"</string>
    <string name="permdesc_setAnimationScale" msgid="7690063428924343571">"Mengizinkan apl mengubah kecepatan animasi global (animasi lebih cepat atau lebih lambat) kapan saja."</string>
    <string name="permlab_manageAppTokens" msgid="1286505717050121370">"mengelola token apl"</string>
    <string name="permdesc_manageAppTokens" msgid="8043431713014395671">"Mengizinkan apl membuat dan mengelola tokennya sendiri, memintas pengurutan Z normalnya. Tidak pernah diperlukan oleh apl normal."</string>
    <string name="permlab_injectEvents" msgid="1378746584023586600">"tekan kunci dan tombol kontrol"</string>
    <string name="permdesc_injectEvents" product="tablet" msgid="206352565599968632">"Mengizinkan apl menyampaikan aktivitas masukannya sendiri (penekanan tombol, dll) ke apl lain. Apl berbahaya dapat menggunakan ini untuk mengambil alih tablet."</string>
    <string name="permdesc_injectEvents" product="default" msgid="653128057572326253">"Mengizinkan apl menyampaikan aktivitas masukannya sendiri (penekanan tombol, dll) ke apl lain. Apl berbahaya dapat menggunakan ini untuk mengambil alih ponsel."</string>
    <string name="permlab_readInputState" msgid="469428900041249234">"rekam apa yang diketik dan tindakan yang dilakukan"</string>
    <string name="permdesc_readInputState" msgid="8387754901688728043">"Mengizinkan apl mengawasi tombol yang Anda tekan bahkan ketika berinteraksi dengan apl lain (misalnya mengetik sandi). Tidak pernah diperlukan oleh apl normal."</string>
    <string name="permlab_bindInputMethod" msgid="3360064620230515776">"mengikat ke metode masukan"</string>
    <string name="permdesc_bindInputMethod" msgid="3250440322807286331">"Mengizinkan pemegang mengikat antarmuka tingkat tinggi dari suatu metode masukan. Tidak pernah diperlukan oleh apl normal."</string>
    <string name="permlab_bindAccessibilityService" msgid="5357733942556031593">"mengikat ke layanan aksesibilitas"</string>
    <string name="permdesc_bindAccessibilityService" msgid="7034615928609331368">"Mengizinkan pemegang untuk mengikat antarmuka tingkat tinggi dari suatu layanan. Tidak pernah diperlukan oleh aplikasi normal."</string>
    <string name="permlab_bindTextService" msgid="7358378401915287938">"mengikat ke layanan SMS"</string>
    <string name="permdesc_bindTextService" msgid="8151968910973998670">"Mengizinkan pemegang mengikat antarmuka tingkat tinggi dari suatu layanan teks (mis. SpellCheckerService). Tidak pernah diperlukan oleh apl normal."</string>
    <string name="permlab_bindVpnService" msgid="4708596021161473255">"mengikat ke layanan VPN"</string>
    <string name="permdesc_bindVpnService" msgid="2067845564581693905">"Mengizinkan pemegang mengikat antarmuka tingkat tinggi dari suatu layanan Vpn. Tidak pernah diperlukan oleh apl normal."</string>
    <string name="permlab_bindWallpaper" msgid="8716400279937856462">"mengikat ke wallpaper"</string>
    <string name="permdesc_bindWallpaper" msgid="7108428692595491668">"Mengizinkan pemegang mengikat antarmuka tingkat tinggi dari suatu wallpaper. Tidak pernah diperlukan oleh apl normal."</string>
    <string name="permlab_bindRemoteViews" msgid="5697987759897367099">"mengikat ke layanan widget"</string>
    <string name="permdesc_bindRemoteViews" msgid="4717987810137692572">"Mengizinkan pemegang mengikat antarmuka tingkat tinggi dari suatu layanan widget. Tidak pernah diperlukan oleh apl normal."</string>
    <string name="permlab_bindDeviceAdmin" msgid="8704986163711455010">"berinteraksi dengan admin perangkat"</string>
    <string name="permdesc_bindDeviceAdmin" msgid="569715419543907930">"Mengizinkan pemegang mengirimkan tujuan kepada administrator perangkat. Tidak pernah diperlukan oleh apl normal."</string>
    <string name="permlab_setOrientation" msgid="3365947717163866844">"ubah orientasi layar"</string>
    <string name="permdesc_setOrientation" msgid="3046126619316671476">"Mengizinkan apl mengubah rotasi layar kapan saja. Tidak pernah dibutuhkan oleh apl normal."</string>
    <string name="permlab_setPointerSpeed" msgid="9175371613322562934">"ubah kecepatan penunjuk"</string>
    <string name="permdesc_setPointerSpeed" msgid="6866563234274104233">"Mengizinkan apl mengubah kecepatan mouse atau pointer trackpad kapan saja. Tidak pernah diperlukan oleh apl normal."</string>
    <string name="permlab_setKeyboardLayout" msgid="4778731703600909340">"Ubah tata letak keyboard"</string>
    <string name="permdesc_setKeyboardLayout" msgid="8480016771134175879">"Memungkinkan aplikasi untuk mengubah tata letak keyboard. Tidak pernah dibutuhkan oleh aplikasi normal."</string>
    <string name="permlab_signalPersistentProcesses" msgid="4539002991947376659">"mengirim sinyal Linux ke apl"</string>
    <string name="permdesc_signalPersistentProcesses" msgid="4896992079182649141">"Mengizinkan apl meminta agar sinyal yang disediakan dikirim ke semua proses yang ada."</string>
    <string name="permlab_persistentActivity" msgid="8841113627955563938">"membuat apl selalu berjalan"</string>
    <string name="permdesc_persistentActivity" product="tablet" msgid="8525189272329086137">"Memungkinkan aplikasi membuat bagian dari dirinya sendiri terus-menerus berada dalam memori. Izin ini dapat membatasi memori yang tersedia untuk aplikasi lain sehingga menjadikan tablet lambat."</string>
    <string name="permdesc_persistentActivity" product="default" msgid="4384760047508278272">"Memungkinkan aplikasi membuat bagian dari dirinya sendiri terus-menerus berada dalam memori. Izin ini dapat membatasi memori yang tersedia untuk aplikasi lain sehingga menjadikan ponsel lambat."</string>
    <string name="permlab_deletePackages" msgid="184385129537705938">"menghapus apl"</string>
    <string name="permdesc_deletePackages" msgid="7411480275167205081">"Mengizinkan apl menghapus paket Android. Apl berbahaya dapat menggunakan ini untuk menghapus apl penting."</string>
    <string name="permlab_clearAppUserData" msgid="274109191845842756">"menghapus data apl lainnya"</string>
    <string name="permdesc_clearAppUserData" msgid="4625323684125459488">"Mengizinkan apl menghapus data pengguna."</string>
    <string name="permlab_deleteCacheFiles" msgid="3128665571837408675">"menghapus cache apl lainnya"</string>
    <string name="permdesc_deleteCacheFiles" msgid="3812998599006730196">"Mengizinkan apl menghapus file cache."</string>
    <string name="permlab_getPackageSize" msgid="7472921768357981986">"mengukur ruang penyimpanan apl"</string>
    <string name="permdesc_getPackageSize" msgid="3921068154420738296">"Mengizinkan apl mengambil kode, data, dan ukuran temboloknya"</string>
    <string name="permlab_installPackages" msgid="2199128482820306924">"langsung memasang apl"</string>
    <string name="permdesc_installPackages" msgid="5628530972548071284">"Mengizinkan apl memasang paket Android yang baru atau diperbarui. Apl berbahaya dapat menggunakan ini untuk menambahkan apl baru dengan sembarang izin yang kuat."</string>
    <string name="permlab_clearAppCache" msgid="7487279391723526815">"menghapus semua data cache apl"</string>
    <string name="permdesc_clearAppCache" product="tablet" msgid="3523396284474042284">"Mengizinkan apl mengosongkan penyimpanan tablet dengan menghapus file dalam direktori cache apl. Akses biasanya sangat terbatas dan hanya diberikan bagi proses sistem."</string>
    <string name="permdesc_clearAppCache" product="default" msgid="5067988373366292186">"Mengizinkan apl mengosongkan penyimpanan ponsel dengan menghapus file dalam direktori cache apl. Akses biasanya sangat terbatas dan hanya diberikan bagi proses sistem."</string>
    <string name="permlab_movePackage" msgid="3289890271645921411">"memindahkan sumber daya apl"</string>
    <string name="permdesc_movePackage" msgid="319562217778244524">"Mengizinkan apl memindahkan sumber daya apl dari media internal ke eksternal dan sebaliknya."</string>
    <string name="permlab_readLogs" msgid="6615778543198967614">"baca data log sensitif"</string>
    <string name="permdesc_readLogs" product="tablet" msgid="82061313293455151">"Mengizinkan apl membaca dari berbagai file log sistem. Izin ini memungkinkan apl menemukan informasi umum tentang hal-hal yang Anda lakukan dengan tablet, kemungkinan termasuk informasi pribadi."</string>
    <string name="permdesc_readLogs" product="default" msgid="2063438140241560443">"Mengizinkan apl membaca dari berbagai file log sistem. Izin ini memungkinkan apl menemukan informasi umum tentang hal-hal yang Anda lakukan di ponsel, kemungkinan termasuk informasi pribadi."</string>
    <string name="permlab_anyCodecForPlayback" msgid="715805555823881818">"menggunakan media pengawasandi apa pun untuk pemutaran"</string>
    <string name="permdesc_anyCodecForPlayback" msgid="8283912488433189010">"Mengizinkan apl menggunakan pengawasandi media apa pun yang terpasang guna mengawasandikan media untuk diputar."</string>
    <string name="permlab_diagnostic" msgid="8076743953908000342">"baca/tulis ke sumber daya yang dimiliki oleh diag"</string>
    <string name="permdesc_diagnostic" msgid="6608295692002452283">"Mengizinkan apl membaca dan menulis ke sumber daya apa pun yang dimiliki oleh grup diag; misalnya, file dalam /dev. Izin ini berpotensi memengaruhi kestabilan dan keamanan sistem. Sebaiknya ini HANYA digunakan untuk diagnosis khusus perangkat keras oleh pabrikan atau operator."</string>
    <string name="permlab_changeComponentState" msgid="6335576775711095931">"mengaktifkan atau menonaktifkan komponen apl"</string>
    <string name="permdesc_changeComponentState" product="tablet" msgid="8887435740982237294">"Mengizinkan apl mengubah apakah komponen apl lain diaktifkan atau tidak. Apl berbahaya dapat menggunakan ini untuk menonaktifkan kemampuan tablet yang penting. Izin ini harus digunakan dengan hati-hati karena dapat menjadikan komponen apl tidak dapat digunakan, tidak konsisten, atau tidak stabil."</string>
    <string name="permdesc_changeComponentState" product="default" msgid="1827232484416505615">"Mengizinkan apl mengubah apakah komponen apl lain diaktifkan atau tidak. Apl berbahaya dapat menggunakan izin ini untuk menonaktifkan kemampuan ponsel yang penting. Izin ini harus digunakan dengan hati-hati, karena mungkin saja menjadikan komponen apl tidak dapat digunakan, tidak konsisten, atau tidak stabil."</string>
    <string name="permlab_grantRevokePermissions" msgid="4627315351093508795">"memberi atau mencabut izin"</string>
    <string name="permdesc_grantRevokePermissions" msgid="4088642654085850662">"Memungkinkan aplikasi memberikan atau mencabut izin khusus untuk aplikasi tersebut atau aplikasi lainnya. Aplikasi berbahaya dapat menggunakannya untuk mengakses fitur yang tidak Anda beri izin."</string>
    <string name="permlab_setPreferredApplications" msgid="8463181628695396391">"menyetel apl yang disukai"</string>
    <string name="permdesc_setPreferredApplications" msgid="4973986762241783712">"Mengizinkan apl memodifikasi apl pilihan Anda. Apl berbahaya dapat diam-diam mengubah apl yang berjalan, menipu apl yang ada untuk mengumpulkan data pribadi dari Anda."</string>
    <string name="permlab_writeSettings" msgid="2226195290955224730">"ubah setelan sistem"</string>
    <string name="permdesc_writeSettings" msgid="7775723441558907181">"Mengizinkan apl memodifikasi data setelan sistem. Apl berbahaya dapat merusak konfigurasi sistem anda."</string>
    <string name="permlab_writeSecureSettings" msgid="204676251876718288">"ubah setelan sistem aman"</string>
    <string name="permdesc_writeSecureSettings" msgid="8159535613020137391">"Mengizinkan apl memodifikasi data setelan aman sistem. Tidak untuk digunakan oleh apl normal."</string>
    <string name="permlab_writeGservices" msgid="2149426664226152185">"ubah peta layanan Google"</string>
    <string name="permdesc_writeGservices" msgid="1287309437638380229">"Mengizinkan apl memodifikasi peta layanan Google. Tidak untuk digunakan oleh apl normal."</string>
    <string name="permlab_receiveBootCompleted" msgid="5312965565987800025">"dijalankan saat dimulai"</string>
    <string name="permdesc_receiveBootCompleted" product="tablet" msgid="7390304664116880704">"Mengizinkan apl memulai sendiri segera setelah sistem selesai booting. Hal ini dapat memperpanjang waktu yang diperlukan untuk memulai tablet dan memungkinkan apl memperlambat tablet secara keseluruhan jika terus berjalan."</string>
    <string name="permdesc_receiveBootCompleted" product="default" msgid="513950589102617504">"Mengizinkan apl memulai sendiri segera setelah sistem selesai booting. Hal ini dapat memperpanjang waktu yang diperlukan untuk memulai ponsel dan memungkinkan apl memperlambat ponsel secara keseluruhan jika terus berjalan."</string>
    <string name="permlab_broadcastSticky" msgid="7919126372606881614">"kirim siaran memikat"</string>
    <string name="permdesc_broadcastSticky" product="tablet" msgid="7749760494399915651">"Memungkinkan aplikasi mengirim siaran permanen, yang tetap ada setelah siaran berakhir. Penggunaan yang berlebihan dapat membuat tablet menjadi lambat atau tidak stabil dengan memicu penggunaan memori yang terlalu banyak."</string>
    <string name="permdesc_broadcastSticky" product="default" msgid="2825803764232445091">"Memungkinkan aplikasi mengirim siaran permanen, yang tetap ada setelah siaran berakhir. Penggunaan yang berlebihan dapat membuat ponsel menjadi lambat atau tidak stabil dengan memicu penggunaan memori yang terlalu banyak."</string>
    <string name="permlab_readContacts" msgid="8348481131899886131">"baca kontak Anda"</string>
    <string name="permdesc_readContacts" product="tablet" msgid="5294866856941149639">"Memungkinkan aplikasi membaca data tentang kontak yang disimpan pada tablet Anda, termasuk frekuensi Anda dalam melakukan panggilan, mengirim email, atau berkomunikasi dengan cara lain dengan individu tertentu. Izin ini memungkinkan aplikasi menyimpan data kontak, dan aplikasi berbahaya dapat berbagi data kontak tanpa sepengetahuan Anda."</string>
    <string name="permdesc_readContacts" product="default" msgid="8440654152457300662">"Memungkinkan aplikasi membaca data tentang kontak yang disimpan pada ponsel Anda, termasuk frekuensi Anda dalam melakukan panggilan, mengirim email, atau berkomunikasi dengan cara lain dengan individu tertentu. Izin ini memungkinkan aplikasi menyimpan data kontak, dan aplikasi berbahaya dapat berbagi data kontak tanpa sepengetahuan Anda."</string>
    <string name="permlab_writeContacts" msgid="5107492086416793544">"ubah kontak Anda"</string>
    <string name="permdesc_writeContacts" product="tablet" msgid="897243932521953602">"Memungkinkan aplikasi mengubah data tentang kontak yang tersimpan dalam tablet Anda, termasuk frekuensi Anda dalam melakukan panggilan, mengirim email, atau berkomunikasi dalam cara lain dengan kontak tertentu. Izin ini memungkinkan aplikasi menghapus data kontak."</string>
    <string name="permdesc_writeContacts" product="default" msgid="589869224625163558">"Memungkinkan aplikasi mengubah data tentang kontak yang tersimpan dalam ponsel Anda, termasuk frekuensi Anda dalam melakukan panggilan, mengirim email, atau berkomunikasi dalam cara lain dengan kontak tertentu. Izin ini memungkinkan aplikasi menghapus data kontak."</string>
    <string name="permlab_readCallLog" msgid="3478133184624102739">"membaca log panggilan"</string>
    <string name="permdesc_readCallLog" product="tablet" msgid="3700645184870760285">"Memungkinkan aplikasi membaca log panggilan tablet Anda, termasuk data tentang panggilan masuk dan keluar. Izin ini memungkinkan aplikasi menyimpan data log panggilan Anda, dan aplikasi berbahaya dapat berbagi data log panggilan tanpa sepengetahuan Anda."</string>
    <string name="permdesc_readCallLog" product="default" msgid="5777725796813217244">"Memungkinkan aplikasi membaca log panggilan ponsel Anda, termasuk data tentang panggilan masuk dan keluar. Izin ini memungkinkan aplikasi menyimpan data log panggilan Anda, dan aplikasi berbahaya dapat berbagi data log panggilan tanpa sepengetahuan Anda."</string>
    <string name="permlab_writeCallLog" msgid="8552045664743499354">"menulis log panggilan"</string>
    <string name="permdesc_writeCallLog" product="tablet" msgid="6661806062274119245">"Memungkinkan apl memodifikasi log panggilan tablet Anda, termasuk data tentang panggilan masuk dan keluar. Apl berbahaya dapat menggunakan ini untuk menghapus atau memodifikasi log panggilan Anda."</string>
    <string name="permdesc_writeCallLog" product="default" msgid="683941736352787842">"Memungkinkan apl memodifikasi log panggilan ponsel Anda, termasuk data tentang panggilan masuk dan keluar. Apl berbahaya dapat menggunakan ini untuk menghapus atau memodifikasi log panggilan Anda."</string>
    <string name="permlab_readProfile" msgid="4701889852612716678">"baca kartu kontak Anda"</string>
    <string name="permdesc_readProfile" product="default" msgid="5462475151849888848">"Memungkinkan aplikasi membaca informasi profil pribadi yang tersimpan di perangkat Anda, misalnya nama dan informasi kontak Anda. Ini artinya aplikasi dapat mengenali dan mengirim informasi profil Anda ke orang lain."</string>
    <string name="permlab_writeProfile" msgid="907793628777397643">"ubah kartu kontak Anda"</string>
    <string name="permdesc_writeProfile" product="default" msgid="5552084294598465899">"Memungkinkan aplikasi mengubah atau menambah informasi profil pribadi yang tersimpan di perangkat Anda, seperti nama dan informasi kontak. Ini berarti aplikasi tersebut dapat mengenali Anda dan mengirim informasi profil Anda ke orang lain."</string>
    <string name="permlab_readSocialStream" product="default" msgid="1268920956152419170">"membaca aliran sosial Anda"</string>
    <string name="permdesc_readSocialStream" product="default" msgid="4255706027172050872">"Memungkinkan aplikasi mengakses dan menyinkronkan pembaruan sosial dari Anda dan teman. Hati-hati ketika berbagi informasi -- izin ini memungkinkan aplikasi membaca komunikasi antara Anda dan teman di jaringan sosial, terlepas dari kerahasiaan. Catatan: izin ini tidak dapat diberlakukan di semua jaringan sosial."</string>
    <string name="permlab_writeSocialStream" product="default" msgid="3504179222493235645">"menulis ke aliran sosial Anda"</string>
    <string name="permdesc_writeSocialStream" product="default" msgid="3086557552204114849">"Memungkinkan aplikasi menampilkan pembaruan sosial dari teman Anda. Berhati-hatilah saat berbagi informasi -- izin ini memungkinkan aplikasi menghasilkan pesan yang mungkin kelihatannya berasal dari seorang teman. Catatan: izin ini tidak dapat diberlakukan di semua jaringan sosial."</string>
    <string name="permlab_readCalendar" msgid="5972727560257612398">"baca acara kalender serta informasi rahasia"</string>
    <string name="permdesc_readCalendar" product="tablet" msgid="4216462049057658723">"Memungkinkan aplikasi membaca semua acara kalender yang tersimpan di tablet Anda, termasuk milik teman atau rekan kerja. Izin ini memungkinkan aplikasi berbagi atau menyimpan data kalender Anda, terlepas dari kerahasiaan atau sensitivitas."</string>
    <string name="permdesc_readCalendar" product="default" msgid="7434548682470851583">"Memungkinkan aplikasi membaca semua acara kalender yang tersimpan di ponsel Anda, termasuk milik teman atau rekan kerja. Izin ini memungkinkan aplikasi berbagi atau menyimpan data kalender Anda, terlepas dari kerahasiaan atau sensitivitas."</string>
    <string name="permlab_writeCalendar" msgid="8438874755193825647">"menambah atau mengubah acara kalender dan mengirim email kepada tamu tanpa sepengetahuan pemilik"</string>
    <string name="permdesc_writeCalendar" product="tablet" msgid="6679035520113668528">"Memungkinkan aplikasi menambahkan, menghapus, mengubah acara yang dapat Anda ubah pada tablet, termasuk acara teman atau rekan kerja. Izin ini memungkinkan aplikasi mengirim pesan yang kelihatannya berasal dari pemilik kalender, atau mengubah acara tanpa sepengetahuan pemilik."</string>
    <string name="permdesc_writeCalendar" product="default" msgid="2324469496327249376">"Memungkinkan aplikasi menambahkan, menghapus, mengubah acara yang dapat Anda ubah pada ponsel, termasuk acara teman atau rekan kerja. Izin ini memungkinkan aplikasi mengirim pesan yang kelihatannya berasal dari pemilik kalender, atau mengubah acara tanpa sepengetahuan pemilik."</string>
    <string name="permlab_accessMockLocation" msgid="8688334974036823330">"sumber lokasi palsu untuk menguji"</string>
    <string name="permdesc_accessMockLocation" msgid="5808711039482051824">"Membuat sumber lokasi palsu untuk uji coba atau memasang penyedia lokasi baru. Izin ini memungkinkan aplikasi mengganti lokasi dan/atau status yang dimunculkan sumber lokasi lain, misalnya GPS atau penyedia lokasi."</string>
    <string name="permlab_accessLocationExtraCommands" msgid="2836308076720553837">"akses perintah penyedia lokasi ekstra"</string>
    <string name="permdesc_accessLocationExtraCommands" msgid="5945166642335800763">"Memungkinkan aplikasi mengakses perintah penyedia lokasi ekstra. Izin ini dapat memungkinkan aplikasi mengganggu pengoperasian GPS atau sumber lokasi lain."</string>
    <string name="permlab_installLocationProvider" msgid="6578101199825193873">"izin untuk memasang suatu penyedia lokasi"</string>
    <string name="permdesc_installLocationProvider" msgid="9066146120470591509">"Membuat sumber lokasi palsu untuk uji coba atau memasang penyedia lokasi baru. Izin ini memungkinkan aplikasi mengganti lokasi dan/atau status yang dimunculkan sumber lokasi lain, misalnya GPS atau penyedia lokasi."</string>
    <string name="permlab_accessFineLocation" msgid="5885550969882561436">"lokasi (GPS) yang tepat"</string>
    <string name="permdesc_accessFineLocation" product="tablet" msgid="8960597421469894181">"Mengakses sumber lokasi yang tepat, misalnya Sistem Pemosisian Global (GPS) di tablet. Ketika layanan lokasi tersedia dan diaktifkan, izin ini memungkinkan aplikasi menentukan lokasi Anda yang tepat."</string>
    <string name="permdesc_accessFineLocation" product="default" msgid="239268765496141815">"Mengakses sumber lokasi yang tepat, misalnya Sistem Pemosisian Global (GPS) di ponsel. Ketika layanan lokasi tersedia dan diaktifkan, izin ini memungkinkan aplikasi menentukan lokasi Anda yang tepat."</string>
    <string name="permlab_accessCoarseLocation" msgid="7422827215441638984">"perkiraan lokasi (berbasis jaringan)"</string>
    <string name="permdesc_accessCoarseLocation" msgid="5383798877137640762">"Mengakses perkiraan lokasi dari penyedia lokasi menggunakan sumber jaringan, misalnya menara seluler dan Wi-Fi. Ketika layanan lokasi ini tersedia dan diaktifkan, izin ini memungkinkan aplikasi menentukan perkiraan lokasi Anda."</string>
    <string name="permlab_accessSurfaceFlinger" msgid="2363969641792388947">"akses SurfaceFlinger"</string>
    <string name="permdesc_accessSurfaceFlinger" msgid="1041619516733293551">"Mengizinkan apl menggunakan fitur tingkat rendah SurfaceFlinger."</string>
    <string name="permlab_readFrameBuffer" msgid="6690504248178498136">"baca buffer frame"</string>
    <string name="permdesc_readFrameBuffer" msgid="4937405521809454680">"Mengizinkan apl membaca konten penyangga frame."</string>
    <string name="permlab_modifyAudioSettings" msgid="6095859937069146086">"ubah setelan audio Anda"</string>
    <string name="permdesc_modifyAudioSettings" msgid="3522565366806248517">"Memungkinkan aplikasi mengubah setelan audio global, misalnya volume dan pengeras suara mana yang digunakan untuk keluaran."</string>
    <string name="permlab_recordAudio" msgid="3876049771427466323">"rekam audio"</string>
    <string name="permdesc_recordAudio" msgid="4906839301087980680">"Memungkinkan aplikasi merekam audio dengan mikrofon. Izin ini memungkinkan aplikasi merekam audio kapan saja tanpa konfirmasi Anda."</string>
    <string name="permlab_camera" msgid="3616391919559751192">"ambil gambar dan video"</string>
    <string name="permdesc_camera" msgid="8497216524735535009">"Memungkinkan aplikasi mengambil gambar dan video dengan kamera. Izin ini memungkinkan aplikasi menggunakan kamera kapan saja tanpa konfirmasi Anda."</string>
    <string name="permlab_brick" product="tablet" msgid="2961292205764488304">"noaktifkan tablet secara permanen"</string>
    <string name="permlab_brick" product="default" msgid="8337817093326370537">"nonaktifkan ponsel secara permanen"</string>
    <string name="permdesc_brick" product="tablet" msgid="4334818808001699530">"Mengizinkan apl menonaktifkan seluruh tablet secara permanen. Ini sangat berbahaya."</string>
    <string name="permdesc_brick" product="default" msgid="5788903297627283099">"Mengizinkan apl menonaktifkan seluruh ponsel secara permanen. Ini sangat berbahaya."</string>
    <string name="permlab_reboot" product="tablet" msgid="3436634972561795002">"reboot tablet secara paksa"</string>
    <string name="permlab_reboot" product="default" msgid="2898560872462638242">"paksa reboot ponsel"</string>
    <string name="permdesc_reboot" product="tablet" msgid="8172056180063700741">"Mengizinkan apl memaksa tablet melakukan reboot."</string>
    <string name="permdesc_reboot" product="default" msgid="5326008124289989969">"Mengizinkan apl memaksa ponsel melakukan reboot."</string>
    <string name="permlab_mount_unmount_filesystems" product="nosdcard" msgid="2927361537942591841">"akses sistem file simpanan USB"</string>
    <string name="permlab_mount_unmount_filesystems" product="default" msgid="4402305049890953810">"akses sistem file Kartu SD"</string>
    <string name="permdesc_mount_unmount_filesystems" msgid="1829290701658992347">"Mengizinkan apl memasang dan melepas sistem file untuk penyimpanan yang dapat dicopot."</string>
    <string name="permlab_mount_format_filesystems" product="nosdcard" msgid="6227819582624904972">"hapus penyimpanan USB"</string>
    <string name="permlab_mount_format_filesystems" product="default" msgid="262582698639274056">"hapus Kartu SD"</string>
    <string name="permdesc_mount_format_filesystems" msgid="8784268246779198627">"Mengizinkan apl memformat penyimpanan yang dapat dicopot."</string>
    <string name="permlab_asec_access" msgid="3411338632002193846">"dapatkan informasi pada penyimpanan internal"</string>
    <string name="permdesc_asec_access" msgid="3094563844593878548">"Mengizinkan apl mendapatkan informasi di penyimpanan internal."</string>
    <string name="permlab_asec_create" msgid="6414757234789336327">"buat penyimpanan internal"</string>
    <string name="permdesc_asec_create" msgid="4558869273585856876">"Mengizinkan apl membuat penyimpanan internal."</string>
    <string name="permlab_asec_destroy" msgid="526928328301618022">"merusak penyimpanan internal"</string>
    <string name="permdesc_asec_destroy" msgid="7218749286145526537">"Mengizinkan apl merusak penyimpanan internal."</string>
    <string name="permlab_asec_mount_unmount" msgid="8877998101944999386">"memasang/melepas penyimpanan internal"</string>
    <string name="permdesc_asec_mount_unmount" msgid="3451360114902490929">"Mengizinkan apl memasang/melepas penyimpanan internal."</string>
    <string name="permlab_asec_rename" msgid="7496633954080472417">"ganti nama penyimpanan internal"</string>
    <string name="permdesc_asec_rename" msgid="1794757588472127675">"Mengizinkan apl mengganti nama penyimpanan internal."</string>
    <string name="permlab_vibrate" msgid="7696427026057705834">"kontrol getaran"</string>
    <string name="permdesc_vibrate" msgid="6284989245902300945">"Mengizinkan aplikasi untuk mengendalikan vibrator."</string>
    <string name="permlab_flashlight" msgid="2155920810121984215">"mengontrol lampu senter"</string>
    <string name="permdesc_flashlight" msgid="6522284794568368310">"Mengizinkan apl mengontrol lampu kilat."</string>
    <string name="permlab_manageUsb" msgid="1113453430645402723">"kelola preferensi dan izin untuk perangkat USB"</string>
    <string name="permdesc_manageUsb" msgid="7776155430218239833">"Mengizinkan apl mengelola preferensi dan izin untuk perangkat USB."</string>
    <string name="permlab_accessMtp" msgid="4953468676795917042">"implementasikan protokol MTP"</string>
    <string name="permdesc_accessMtp" msgid="6532961200486791570">"Izinkan akses pada driver MTP kernel untuk mengimplementasikan protokol USB MTP."</string>
    <string name="permlab_hardware_test" msgid="4148290860400659146">"uji perangkat keras"</string>
    <string name="permdesc_hardware_test" msgid="6597964191208016605">"Mengizinkan apl mengontrol beragam periferal untuk tujuan pengujian perangkat keras."</string>
    <string name="permlab_callPhone" msgid="3925836347681847954">"panggil nomor telepon secara langsung"</string>
    <string name="permdesc_callPhone" msgid="3740797576113760827">"Memungkinkan aplikasi menghubungi nomor telepon tanpa campur tangan Anda. Izin ini dapat mengakibatkan biaya atau panggilan tak terduga. Perhatikan bahwa izin ini tidak memungkinkan aplikasi menghubungi nomor darurat. Aplikasi berbahaya dapat menyebabkan Anda dikenakan biaya dengan melakukan panggilan tanpa konfirmasi Anda."</string>
    <string name="permlab_callPrivileged" msgid="4198349211108497879">"panggil nomor telepon apa pun secara langsung"</string>
    <string name="permdesc_callPrivileged" msgid="1689024901509996810">"Mengizinkan apl memanggil nomor telepon apa pun, termasuk nomor darurat, tanpa campur tangan Anda. Apl berbahaya dapat melakukan panggilan yang tidak perlu dan ilegal ke layanan darurat."</string>
    <string name="permlab_performCdmaProvisioning" product="tablet" msgid="4842576994144604821">"memulai penyiapan tablet CDMA secara langsung"</string>
    <string name="permlab_performCdmaProvisioning" product="default" msgid="5604848095315421425">"mulai penyiapan ponsel CDMA secara langsung"</string>
    <string name="permdesc_performCdmaProvisioning" msgid="1994193538802314186">"Mengizinkan apl memulai penyediaan CDMA. Apl berbahaya dapat memulai penyediaan CDMA yang tidak perlu."</string>
    <string name="permlab_locationUpdates" msgid="7785408253364335740">"mengontrol pemberitahuan pembaruan lokasi"</string>
    <string name="permdesc_locationUpdates" msgid="1120741557891438876">"Mengizinkan apl mengaktifkan/menonaktifkan pemberitahuan pembaruan lokasi dari radio. Tidak untuk digunakan oleh apl normal."</string>
    <string name="permlab_checkinProperties" msgid="7855259461268734914">"akses properti lapor masuk"</string>
    <string name="permdesc_checkinProperties" msgid="4024526968630194128">"Mengizinkan apl membaca/menulis akses ke properti yang diunggah oleh layanan lapor masuk. Tidak untuk digunakan oleh apl normal."</string>
    <string name="permlab_bindGadget" msgid="776905339015863471">"pilih widget"</string>
    <string name="permdesc_bindGadget" msgid="8261326938599049290">"Mengizinkan apl memberi tahu sistem tentang widget mana yang dapat digunakan oleh suatu apl. Apl dengan izin ini dapat memberikan akses ke data pribadi untuk apl lain. Tidak untuk digunakan oleh apl normal."</string>
    <string name="permlab_modifyPhoneState" msgid="8423923777659292228">"ubah kondisi ponsel"</string>
    <string name="permdesc_modifyPhoneState" msgid="1029877529007686732">"Mengizinkan apl mengontrol fitur telepon perangkat. Apl dengan izin ini dapat mengalihkan jaringan, menyalakan dan mematikan radio ponsel, dan melakukan hal serupa lainnya tanpa pernah memberi tahu Anda."</string>
    <string name="permlab_readPhoneState" msgid="9178228524507610486">"baca identitas dan status ponsel"</string>
    <string name="permdesc_readPhoneState" msgid="1639212771826125528">"Memungkinkan aplikasi mengakses fitur telepon perangkat. Izin ini memungkinkan aplikasi menentukan nomor telepon dan ID perangkat, apakah suatu panggilan aktif atau tidak, dan nomor jarak jauh yang tersambung oleh sebuah panggilan."</string>
    <string name="permlab_wakeLock" product="tablet" msgid="1531731435011495015">"cegah tablet dari tidur"</string>
    <string name="permlab_wakeLock" product="default" msgid="573480187941496130">"mencegah ponsel menjadi tidak aktif"</string>
    <string name="permdesc_wakeLock" product="tablet" msgid="7311319824400447868">"Mengizinkan apl mencegah tablet tidur."</string>
    <string name="permdesc_wakeLock" product="default" msgid="8559100677372928754">"Mengizinkan apl mencegah ponsel tidur."</string>
    <string name="permlab_devicePower" product="tablet" msgid="2787034722616350417">"hidupkan atau matikan tablet"</string>
    <string name="permlab_devicePower" product="default" msgid="4928622470980943206">"daya ponsel hidup atau mati"</string>
    <string name="permdesc_devicePower" product="tablet" msgid="6689862878984631831">"Mengizinkan apl menyalakan atau mematikan tablet."</string>
    <string name="permdesc_devicePower" product="default" msgid="6037057348463131032">"Mengizinkan apl mematikan atau menyalakan ponsel."</string>
    <string name="permlab_factoryTest" msgid="3715225492696416187">"jalankan pada mode uji pabrik"</string>
    <string name="permdesc_factoryTest" product="tablet" msgid="3952059318359653091">"Menjalankan sebagai uji pabrikan tingkat rendah, mengizinkan akses lengkap ke perangkat keras tablet. Hanya tersedia jika tablet berjalan dalam mode uji pabrikan."</string>
    <string name="permdesc_factoryTest" product="default" msgid="8136644990319244802">"Jalankan sebagai uji pabrik tingkat rendah, yang memungkinkan akses penuh pada perangkat keras ponsel. Hanya tersedia ketika ponsel berjalan pada mode uji pabrik."</string>
    <string name="permlab_setWallpaper" msgid="6627192333373465143">"atur wallpaper"</string>
    <string name="permdesc_setWallpaper" msgid="7373447920977624745">"Mengizinkan apl menyetel wallpaper sistem."</string>
    <string name="permlab_setWallpaperHints" msgid="3278608165977736538">"sesuaikan ukuran wallpaper Anda"</string>
    <string name="permdesc_setWallpaperHints" msgid="8235784384223730091">"Mengizinkan apl menyetel petunjuk ukuran wallpaper sistem."</string>
    <string name="permlab_masterClear" msgid="2315750423139697397">"setel ulang sistem ke setelan default pabrik"</string>
    <string name="permdesc_masterClear" msgid="3665380492633910226">"Mengizinkan apl menyetel ulang sistem ke setelan pabrik sepenuhnya, menghapus semua data, konfigurasi, dan apl yang terpasang."</string>
    <string name="permlab_setTime" msgid="2021614829591775646">"atur waktu"</string>
    <string name="permdesc_setTime" product="tablet" msgid="1896341438151152881">"Mengizinkan apl mengubah waktu pada jam tablet."</string>
    <string name="permdesc_setTime" product="default" msgid="1855702730738020">"Mengizinkan apl mengubah waktu pada jam ponsel."</string>
    <string name="permlab_setTimeZone" msgid="2945079801013077340">"atur zona waktu"</string>
    <string name="permdesc_setTimeZone" product="tablet" msgid="1676983712315827645">"Mengizinkan apl mengubah zona waktu tablet."</string>
    <string name="permdesc_setTimeZone" product="default" msgid="4499943488436633398">"Mengizinkan apl mengubah zona waktu pada ponsel."</string>
    <string name="permlab_accountManagerService" msgid="4829262349691386986">"bertindak sebagai AccountManagerService"</string>
    <string name="permdesc_accountManagerService" msgid="1948455552333615954">"Mengizinkan apl melakukan panggilan ke AccountAuthenticators."</string>
    <string name="permlab_getAccounts" msgid="1086795467760122114">"cari akun pada perangkat"</string>
    <string name="permdesc_getAccounts" product="tablet" msgid="2741496534769660027">"Memungkinkan aplikasi mendapatkan daftar akun yang dikenal oleh tablet. Ini mungkin termasuk akun yang dibuat oleh aplikasi yang telah Anda pasang."</string>
    <string name="permdesc_getAccounts" product="default" msgid="3448316822451807382">"Memungkinkan aplikasi mendapatkan daftar akun yang dikenal oleh ponsel. Ini mungkin termasuk akun yang dibuat oleh aplikasi yang telah Anda pasang."</string>
    <string name="permlab_authenticateAccounts" msgid="5265908481172736933">"buat akun dan setel sandi"</string>
    <string name="permdesc_authenticateAccounts" msgid="5472124296908977260">"Mengizinkan apl menggunakan kemampuan pengautentikasi akun dari AccountManager, termasuk membuat akun dan mendapatkan serta menyetel sandinya."</string>
    <string name="permlab_manageAccounts" msgid="4983126304757177305">"tambah atau hapus akun"</string>
    <string name="permdesc_manageAccounts" msgid="8698295625488292506">"Mengizinkan apl melakukan operasi seperti menambah dan menghapus akun, serta menghapus sandinya."</string>
    <string name="permlab_useCredentials" msgid="235481396163877642">"gunakan akun pada perangkat"</string>
    <string name="permdesc_useCredentials" msgid="7984227147403346422">"Mengizinkan apl meminta token autentikasi."</string>
    <string name="permlab_accessNetworkState" msgid="4951027964348974773">"lihat sambungan jaringan"</string>
    <string name="permdesc_accessNetworkState" msgid="8318964424675960975">"Memungkinkan aplikasi melihat informasi tentang sambungan jaringan, misalnya jaringan yang ada dan tersambung."</string>
    <string name="permlab_createNetworkSockets" msgid="8018758136404323658">"akses jaringan penuh"</string>
    <string name="permdesc_createNetworkSockets" msgid="3403062187779724185">"Memungkinkan aplikasi membuat soket jaringan dan menggunakan protokol jaringan khusus. Browser dan aplikasi lain menyediakan sarana untuk mengirim data ke internet sehingga izin ini tidak diperlukan untuk mengirim data ke internet."</string>
    <string name="permlab_writeApnSettings" msgid="505660159675751896">"mengubah/mencegat lalu lintas dan setelan jaringan"</string>
    <string name="permdesc_writeApnSettings" msgid="5333798886412714193">"Mengizinkan apl mengubah setelan jaringan dan mencegat serta memeriksa semua lalu lintas jaringan, misalnya mengubah proxy dan port APN apa saja. Apl berbahaya dapat memantau, mengalihkan, atau mengubah paket jaringan tanpa sepengetahuan Anda."</string>
    <string name="permlab_changeNetworkState" msgid="958884291454327309">"ubah konektivitas jaringan"</string>
    <string name="permdesc_changeNetworkState" msgid="6789123912476416214">"Mengizinkan apl mengubah keadaan konektivitas jaringan."</string>
    <string name="permlab_changeTetherState" msgid="5952584964373017960">"mengubah konektivitas yang tertambat"</string>
    <string name="permdesc_changeTetherState" msgid="1524441344412319780">"Mengizinkan apl mengubah status konektivitas jaringan yang tertambat."</string>
    <string name="permlab_changeBackgroundDataSetting" msgid="1400666012671648741">"mengubah setelan penggunaan data latar belakang"</string>
    <string name="permdesc_changeBackgroundDataSetting" msgid="5347729578468744379">"Mengizinkan apl mengubah setelan penggunaan data latar belakang."</string>
    <string name="permlab_accessWifiState" msgid="5202012949247040011">"lihat sambungan Wi-Fi"</string>
    <string name="permdesc_accessWifiState" msgid="5002798077387803726">"Memungkinkan aplikasi melihat informasi tentang jaringan Wi-Fi, misalnya apakah Wi-Fi diaktifkan dan nama perangkat Wi-Fi yang tersambung."</string>
    <string name="permlab_changeWifiState" msgid="6550641188749128035">"sambung dan putuskan Wi-Fi"</string>
    <string name="permdesc_changeWifiState" msgid="7137950297386127533">"Memungkinkan aplikasi menyambung ke dan memutus dari titik akses Wi-Fi, dan mengubah konfigurasi perangkat untuk jaringan Wi-Fi."</string>
    <string name="permlab_changeWifiMulticastState" msgid="1368253871483254784">"Izinkan penerimaan Wi-Fi Multicast"</string>
    <string name="permdesc_changeWifiMulticastState" product="tablet" msgid="7969774021256336548">"Memungkinkan aplikasi menerima paket yang dikirim ke semua perangkat melalui jaringan Wi-Fi menggunakan alamat multicast, bukan hanya tablet Anda. Izin ini akan menggunakan lebih banyak daya daripada mode selain multicast."</string>
    <string name="permdesc_changeWifiMulticastState" product="default" msgid="6851949706025349926">"Memungkinkan aplikasi menerima paket yang dikirim ke semua perangkat melalui jaringan Wi-Fi menggunakan alamat multicast, bukan hanya ponsel Anda. Izin ini akan menggunakan lebih banyak daya daripada mode selain multicast."</string>
    <string name="permlab_bluetoothAdmin" msgid="6006967373935926659">"akses setelan Bluetooth"</string>
    <string name="permdesc_bluetoothAdmin" product="tablet" msgid="6921177471748882137">"Mengizinkan apl mengonfigurasi tablet Bluetooth lokal, dan menemukan serta menyandingkan dengan perangkat jarak jauh."</string>
    <string name="permdesc_bluetoothAdmin" product="default" msgid="8931682159331542137">"Mengizinkan apl mengonfigurasi ponsel Bluetooth lokal, dan menemukan serta menyandingkan dengan perangkat jarak jauh."</string>
    <string name="permlab_accessWimaxState" msgid="7436749103151096452">"Lihat sambungan WiMAX"</string>
    <string name="permdesc_accessWimaxState" msgid="6360102877261978887">"Memungkinkan aplikasi menentukan apakah WiMAX diaktifkan dan informasi tentang jaringan WiMAX apa saja yang tersambung."</string>
    <string name="permlab_changeWimaxState" msgid="2405042267131496579">"Ubah status WiMAX"</string>
    <string name="permdesc_changeWimaxState" product="tablet" msgid="3156456504084201805">"Memungkinkan aplikasi menyambungkan tablet ke dan memutus tablet dari jaringan WiMAX."</string>
    <string name="permdesc_changeWimaxState" product="default" msgid="697025043004923798">"Memungkinkan aplikasi menyambungkan ponsel ke dan memutus ponsel dari jaringan WiMAX."</string>
    <string name="permlab_bluetooth" msgid="6127769336339276828">"sandingkan dengan perangkat Bluetooth"</string>
    <string name="permdesc_bluetooth" product="tablet" msgid="3480722181852438628">"Memungkinkan aplikasi melihat konfigurasi Bluetooth di tablet, dan membuat serta menerima sambungan dengan perangkat yang disandingkan."</string>
    <string name="permdesc_bluetooth" product="default" msgid="3207106324452312739">"Memungkinkan aplikasi melihat konfigurasi Bluetooth di ponsel, dan membuat serta menerima sambungan dengan perangkat yang disandingkan."</string>
    <string name="permlab_nfc" msgid="4423351274757876953">"kontrol NFC"</string>
    <string name="permdesc_nfc" msgid="7120611819401789907">"Mengizinkan apl berkomunikasi dengan tag, kartu, dan alat pembaca Komunikasi Nirkabel Jarak Dekat (NFC)."</string>
    <string name="permlab_disableKeyguard" msgid="3598496301486439258">"nonaktifkan kunci layar Anda"</string>
    <string name="permdesc_disableKeyguard" msgid="6034203065077122992">"Memungkinkan aplikasi menonaktifkan kunci tombol dan keamanan sandi apa pun yang terkait. Misalnya, ponsel menonaktifkan kunci tombol saat menerima panggilan telepon masuk, kemudian mengaktifkan kembali kunci tombol ketika panggilan selesai."</string>
    <string name="permlab_readSyncSettings" msgid="6201810008230503052">"baca setelan sinkron"</string>
    <string name="permdesc_readSyncSettings" msgid="2706745674569678644">"Memungkinkan aplikasi membaca setelan sinkronisasi untuk sebuah akun. Misalnya, izin ini dapat menentukan apakah aplikasi Orang disinkronkan dengan sebuah akun."</string>
    <string name="permlab_writeSyncSettings" msgid="5408694875793945314">"nyalakan dan matikan sinkronisasi"</string>
    <string name="permdesc_writeSyncSettings" msgid="8956262591306369868">"Memungkinkan aplikasi mengubah setelan sinkronisasi untuk sebuah akun. Misalnya, izin ini dapat digunakan untuk mengaktifkan sinkronisasi dari aplikasi Orang dengan sebuah akun."</string>
    <string name="permlab_readSyncStats" msgid="7396577451360202448">"statistika baca sinkron"</string>
    <string name="permdesc_readSyncStats" msgid="1510143761757606156">"Memungkinkan aplikasi membaca statistik sinkronisasi untuk sebuah akun, termasuk riwayat kejadian sinkronisasi dan berapa banyak data yang disinkronkan."</string>
    <string name="permlab_subscribedFeedsRead" msgid="4756609637053353318">"baca umpan langganan"</string>
    <string name="permdesc_subscribedFeedsRead" msgid="5557058907906144505">"Mengizinkan apl mendapatkan detail tentang umpan yang saat ini sedang disinkronkan."</string>
    <string name="permlab_subscribedFeedsWrite" msgid="9015246325408209296">"tuliskan umpan langganan"</string>
    <string name="permdesc_subscribedFeedsWrite" msgid="6928930188826089413">"Mengizinkan apl memodifikasi umpan Anda yang disinkronkan saat ini. Apl berbahaya dapat mengubah umpan Anda yang disinkronkan."</string>
    <string name="permlab_readDictionary" msgid="4107101525746035718">"baca istilah yang Anda tambahkan ke kamus"</string>
    <string name="permdesc_readDictionary" msgid="659614600338904243">"Memungkinkan aplikasi membaca semua kata, nama, dan frasa yang mungkin disimpan oleh pengguna di kamus pengguna."</string>
    <string name="permlab_writeDictionary" msgid="2296383164914812772">"menulis ke kamus yang dibuat pengguna"</string>
    <string name="permdesc_writeDictionary" msgid="8185385716255065291">"Mengizinkan apl menulis kata-kata baru ke dalam kamus pengguna."</string>
    <string name="permlab_sdcardRead" product="nosdcard" msgid="8235341515605559677">"akses uji coba ke penyimpanan yang dilindungi"</string>
    <string name="permlab_sdcardRead" product="default" msgid="8235341515605559677">"akses uji coba ke penyimpanan yang dilindungi"</string>
    <string name="permdesc_sdcardRead" product="nosdcard" msgid="5791957130190763289">"Memungkinkan aplikasi menguji izin untuk penyimpanan USB yang akan tersedia pada perangkat yang akan datang."</string>
    <string name="permdesc_sdcardRead" product="default" msgid="5914402684685848828">"Memungkinkan aplikasi menguji izin untuk kartu SD yang akan tersedia pada perangkat yang akan datang."</string>
    <string name="permlab_sdcardWrite" product="nosdcard" msgid="8485979062254666748">"ubah/hapus konten pympanan USB"</string>
    <string name="permlab_sdcardWrite" product="default" msgid="8805693630050458763">"mengubah atau menghapus konten kartu SD Anda"</string>
    <string name="permdesc_sdcardWrite" product="nosdcard" msgid="6175406299445710888">"Mengizinkan apl menulis ke penyimpanan USB."</string>
    <string name="permdesc_sdcardWrite" product="default" msgid="4337417790936632090">"Memungkinkan apl menulis ke kartu SD."</string>
    <string name="permlab_mediaStorageWrite" product="default" msgid="6859839199706879015">"ubah/hapus konten penyimpanan media internal"</string>
    <string name="permdesc_mediaStorageWrite" product="default" msgid="8189160597698529185">"Mengizinkan apl memodifikasi konten penyimpanan media internal."</string>
    <string name="permlab_cache_filesystem" msgid="5656487264819669824">"akses sistem file cache."</string>
    <string name="permdesc_cache_filesystem" msgid="5578967642265550955">"Mengizinkan apl membaca dan menulis pada sistem file cache."</string>
    <string name="permlab_use_sip" msgid="5986952362795870502">"lakukan//terima panggilan internet"</string>
    <string name="permdesc_use_sip" msgid="4717632000062674294">"Mengizinkan apl menggunakan layanan SIP untuk melakukan/menerima panggilan internet."</string>
    <string name="permlab_readNetworkUsageHistory" msgid="7862593283611493232">"baca riwayat penggunaan jaringan"</string>
    <string name="permdesc_readNetworkUsageHistory" msgid="7689060749819126472">"Mengizinkan apl membaca penggunaan jaringan historis untuk apl dan jaringan tertentu."</string>
    <string name="permlab_manageNetworkPolicy" msgid="2562053592339859990">"kelola kebijakan jaringan"</string>
    <string name="permdesc_manageNetworkPolicy" msgid="7537586771559370668">"Mengizinkan apl mengelola kebijakan jaringan dan menentukan peraturan khusus apl."</string>
    <string name="permlab_modifyNetworkAccounting" msgid="5088217309088729650">"mengubah penghitungan penggunaan jaringan"</string>
    <string name="permdesc_modifyNetworkAccounting" msgid="5443412866746198123">"Mengizinkan apl memodifikasi cara penggunaan jaringan diperhitungkan terhadap apl. Tidak untuk digunakan oleh apl normal."</string>
    <string name="policylab_limitPassword" msgid="4497420728857585791">"Setel aturan sandi"</string>
    <string name="policydesc_limitPassword" msgid="3252114203919510394">"Kontrol panjang dan karakter yang diizinkan dalam sandi pembuka layar."</string>
    <string name="policylab_watchLogin" msgid="914130646942199503">"Upaya pembukaan kunci layar monitor"</string>
    <string name="policydesc_watchLogin" product="tablet" msgid="3215729294215070072">"Memantau jumlah sandi yang salah ketik saat membuka kunci layar, dan mengunci tablet atau menghapus semua data tablet jika sandi yang salah ketik terlalu banyak."</string>
    <string name="policydesc_watchLogin" product="default" msgid="5712323091846761073">"Memantau jumlah sandi salah ketik saat membuka kunci layar, dan mengunci ponsel atau menghapus semua data ponsel jika sandi yang salah ketik terlalu banyak."</string>
    <string name="policylab_resetPassword" msgid="2620077191242688955">"Ubah sandi pembuka kunci layar"</string>
    <string name="policydesc_resetPassword" msgid="605963962301904458">"Ubah sandi pembuka kunci layar."</string>
    <string name="policylab_forceLock" msgid="2274085384704248431">"Kunci layar"</string>
    <string name="policydesc_forceLock" msgid="1141797588403827138">"Kontrol cara dan kapan layar mengunci."</string>
    <string name="policylab_wipeData" msgid="3910545446758639713">"Hapus semua data"</string>
    <string name="policydesc_wipeData" product="tablet" msgid="4306184096067756876">"Hapus data tablet tanpa peringatan dengan menyetel ulang data pabrik."</string>
    <string name="policydesc_wipeData" product="default" msgid="5096895604574188391">"Hapus data ponsel tanpa peringatan dengan menyetel ulang data pabrik."</string>
    <string name="policylab_setGlobalProxy" msgid="2784828293747791446">"Setel proxy global perangkat"</string>
    <string name="policydesc_setGlobalProxy" msgid="6387497466660154931">"Setel proxy global perangkat yang akandigunakan ketika kebijakan diaktifkan. Hanya admin perangkat pertama yang menyetel procy global yang berlaku."</string>
    <string name="policylab_expirePassword" msgid="885279151847254056">"Setel kedaluwarsa sandi pengunci layar"</string>
    <string name="policydesc_expirePassword" msgid="1729725226314691591">"Kontrol seberapa sering sandi pengunci layar harus diganti."</string>
    <string name="policylab_encryptedStorage" msgid="8901326199909132915">"Setel enkripsi penyimpanan"</string>
    <string name="policydesc_encryptedStorage" msgid="2637732115325316992">"Mengharuskan data apl yang disimpan untuk dienkripsi."</string>
    <string name="policylab_disableCamera" msgid="6395301023152297826">"Nonaktifkan kamera"</string>
    <string name="policydesc_disableCamera" msgid="2306349042834754597">"Mencegah penggunaan semua kamera perangkat."</string>
  <string-array name="phoneTypes">
    <item msgid="8901098336658710359">"Rumah"</item>
    <item msgid="869923650527136615">"Seluler"</item>
    <item msgid="7897544654242874543">"Kantor"</item>
    <item msgid="1103601433382158155">"Faks Kantor"</item>
    <item msgid="1735177144948329370">"Faks Rumah"</item>
    <item msgid="603878674477207394">"Pager"</item>
    <item msgid="1650824275177931637">"Lainnya"</item>
    <item msgid="9192514806975898961">"Khusus"</item>
  </string-array>
  <string-array name="emailAddressTypes">
    <item msgid="8073994352956129127">"Rumah"</item>
    <item msgid="7084237356602625604">"Kantor"</item>
    <item msgid="1112044410659011023">"Lainnya"</item>
    <item msgid="2374913952870110618">"Khusus"</item>
  </string-array>
  <string-array name="postalAddressTypes">
    <item msgid="6880257626740047286">"Rumah"</item>
    <item msgid="5629153956045109251">"Kantor"</item>
    <item msgid="4966604264500343469">"Lainnya"</item>
    <item msgid="4932682847595299369">"Khusus"</item>
  </string-array>
  <string-array name="imAddressTypes">
    <item msgid="1738585194601476694">"Rumah"</item>
    <item msgid="1359644565647383708">"Kantor"</item>
    <item msgid="7868549401053615677">"Lainnya"</item>
    <item msgid="3145118944639869809">"Khusus"</item>
  </string-array>
  <string-array name="organizationTypes">
    <item msgid="7546335612189115615">"Kantor"</item>
    <item msgid="4378074129049520373">"Lainnya"</item>
    <item msgid="3455047468583965104">"Khusus"</item>
  </string-array>
  <string-array name="imProtocols">
    <item msgid="8595261363518459565">"AIM"</item>
    <item msgid="7390473628275490700">"Windows Live"</item>
    <item msgid="7882877134931458217">"Yahoo"</item>
    <item msgid="5035376313200585242">"Skype"</item>
    <item msgid="7532363178459444943">"QQ"</item>
    <item msgid="3713441034299660749">"Google Talk"</item>
    <item msgid="2506857312718630823">"ICQ"</item>
    <item msgid="1648797903785279353">"Jabber"</item>
  </string-array>
    <string name="phoneTypeCustom" msgid="1644738059053355820">"Khusus"</string>
    <string name="phoneTypeHome" msgid="2570923463033985887">"Rumah"</string>
    <string name="phoneTypeMobile" msgid="6501463557754751037">"Seluler"</string>
    <string name="phoneTypeWork" msgid="8863939667059911633">"Kantor"</string>
    <string name="phoneTypeFaxWork" msgid="3517792160008890912">"Faks Kantor"</string>
    <string name="phoneTypeFaxHome" msgid="2067265972322971467">"Faks Rumah"</string>
    <string name="phoneTypePager" msgid="7582359955394921732">"Pager"</string>
    <string name="phoneTypeOther" msgid="1544425847868765990">"Lainnya"</string>
    <string name="phoneTypeCallback" msgid="2712175203065678206">"Panggil balik"</string>
    <string name="phoneTypeCar" msgid="8738360689616716982">"Mobil"</string>
    <string name="phoneTypeCompanyMain" msgid="540434356461478916">"Utama Perusahaan"</string>
    <string name="phoneTypeIsdn" msgid="8022453193171370337">"ISDN"</string>
    <string name="phoneTypeMain" msgid="6766137010628326916">"Utama"</string>
    <string name="phoneTypeOtherFax" msgid="8587657145072446565">"Faks Lain"</string>
    <string name="phoneTypeRadio" msgid="4093738079908667513">"Radio"</string>
    <string name="phoneTypeTelex" msgid="3367879952476250512">"Teleks"</string>
    <string name="phoneTypeTtyTdd" msgid="8606514378585000044">"TTY/TDD"</string>
    <string name="phoneTypeWorkMobile" msgid="1311426989184065709">"Ponsel Kantor"</string>
    <string name="phoneTypeWorkPager" msgid="649938731231157056">"Pager Kantor"</string>
    <string name="phoneTypeAssistant" msgid="5596772636128562884">"Asisten"</string>
    <string name="phoneTypeMms" msgid="7254492275502768992">"MMS"</string>
    <string name="eventTypeCustom" msgid="7837586198458073404">"Khusus"</string>
    <string name="eventTypeBirthday" msgid="2813379844211390740">"Hari Ulang Tahun"</string>
    <string name="eventTypeAnniversary" msgid="3876779744518284000">"Hari Peringatan"</string>
    <string name="eventTypeOther" msgid="7388178939010143077">"Lainnya"</string>
    <string name="emailTypeCustom" msgid="8525960257804213846">"Khusus"</string>
    <string name="emailTypeHome" msgid="449227236140433919">"Rumah"</string>
    <string name="emailTypeWork" msgid="3548058059601149973">"Kantor"</string>
    <string name="emailTypeOther" msgid="2923008695272639549">"Lainnya"</string>
    <string name="emailTypeMobile" msgid="119919005321166205">"Seluler"</string>
    <string name="postalTypeCustom" msgid="8903206903060479902">"Khusus"</string>
    <string name="postalTypeHome" msgid="8165756977184483097">"Rumah"</string>
    <string name="postalTypeWork" msgid="5268172772387694495">"Kantor"</string>
    <string name="postalTypeOther" msgid="2726111966623584341">"Lainnya"</string>
    <string name="imTypeCustom" msgid="2074028755527826046">"Khusus"</string>
    <string name="imTypeHome" msgid="6241181032954263892">"Rumah"</string>
    <string name="imTypeWork" msgid="1371489290242433090">"Kantor"</string>
    <string name="imTypeOther" msgid="5377007495735915478">"Lainnya"</string>
    <string name="imProtocolCustom" msgid="6919453836618749992">"Khusus"</string>
    <string name="imProtocolAim" msgid="7050360612368383417">"AIM"</string>
    <string name="imProtocolMsn" msgid="144556545420769442">"Windows Live"</string>
    <string name="imProtocolYahoo" msgid="8271439408469021273">"Yahoo"</string>
    <string name="imProtocolSkype" msgid="9019296744622832951">"Skype"</string>
    <string name="imProtocolQq" msgid="8887484379494111884">"QQ"</string>
    <string name="imProtocolGoogleTalk" msgid="3808393979157698766">"Google Talk"</string>
    <string name="imProtocolIcq" msgid="1574870433606517315">"ICQ"</string>
    <string name="imProtocolJabber" msgid="2279917630875771722">"Jabber"</string>
    <string name="imProtocolNetMeeting" msgid="8287625655986827971">"NetMeeting"</string>
    <string name="orgTypeWork" msgid="29268870505363872">"Kantor"</string>
    <string name="orgTypeOther" msgid="3951781131570124082">"Lainnya"</string>
    <string name="orgTypeCustom" msgid="225523415372088322">"Khusus"</string>
    <string name="relationTypeCustom" msgid="3542403679827297300">"Khusus"</string>
    <string name="relationTypeAssistant" msgid="6274334825195379076">"Asisten"</string>
    <string name="relationTypeBrother" msgid="8757913506784067713">"Saudara laki-laki"</string>
    <string name="relationTypeChild" msgid="1890746277276881626">"Anak"</string>
    <string name="relationTypeDomesticPartner" msgid="6904807112121122133">"Mitra Serumah"</string>
    <string name="relationTypeFather" msgid="5228034687082050725">"Ayah"</string>
    <string name="relationTypeFriend" msgid="7313106762483391262">"Teman"</string>
    <string name="relationTypeManager" msgid="6365677861610137895">"Manajer"</string>
    <string name="relationTypeMother" msgid="4578571352962758304">"Ibu"</string>
    <string name="relationTypeParent" msgid="4755635567562925226">"Orang tua"</string>
    <string name="relationTypePartner" msgid="7266490285120262781">"Mitra"</string>
    <string name="relationTypeReferredBy" msgid="101573059844135524">"Dirujuk oleh"</string>
    <string name="relationTypeRelative" msgid="1799819930085610271">"Sanak saudara"</string>
    <string name="relationTypeSister" msgid="1735983554479076481">"Saudara perempuan"</string>
    <string name="relationTypeSpouse" msgid="394136939428698117">"Pasangan"</string>
    <string name="sipAddressTypeCustom" msgid="2473580593111590945">"Khusus"</string>
    <string name="sipAddressTypeHome" msgid="6093598181069359295">"Beranda"</string>
    <string name="sipAddressTypeWork" msgid="6920725730797099047">"Kerjaan"</string>
    <string name="sipAddressTypeOther" msgid="4408436162950119849">"Lainnya"</string>
    <string name="keyguard_password_enter_pin_code" msgid="3037685796058495017">"Ketik kode PIN"</string>
    <string name="keyguard_password_enter_puk_code" msgid="4800725266925845333">"Ketik kode PUK dan PIN baru"</string>
    <string name="keyguard_password_enter_puk_prompt" msgid="1341112146710087048">"Kode PUK"</string>
    <string name="keyguard_password_enter_pin_prompt" msgid="8027680321614196258">"Kode Pin baru"</string>
    <string name="keyguard_password_entry_touch_hint" msgid="7858547464982981384"><font size="17">"Sentuh untuk mengetikkan sandi"</font></string>
    <string name="keyguard_password_enter_password_code" msgid="1054721668279049780">"Ketik sandi untuk membuka kunci"</string>
    <string name="keyguard_password_enter_pin_password_code" msgid="6391755146112503443">"Ketik PIN untuk membuka kunci"</string>
    <string name="keyguard_password_wrong_pin_code" msgid="2422225591006134936">"Kode PIN salah."</string>
    <string name="keyguard_label_text" msgid="861796461028298424">"Untuk membuka, tekan Menu lalu 0."</string>
    <string name="emergency_call_dialog_number_for_display" msgid="696192103195090970">"Nomor darurat"</string>
    <string name="lockscreen_carrier_default" msgid="8963839242565653192">"Tidak ada layanan."</string>
    <string name="lockscreen_screen_locked" msgid="7288443074806832904">"Layar terkunci."</string>
    <string name="lockscreen_instructions_when_pattern_enabled" msgid="46154051614126049">"Tekan Menu untuk membuka atau melakukan panggilan darurat."</string>
    <string name="lockscreen_instructions_when_pattern_disabled" msgid="686260028797158364">"Tekan Menu untuk membuka."</string>
    <string name="lockscreen_pattern_instructions" msgid="7478703254964810302">"Buat pola untuk membuka"</string>
    <string name="lockscreen_emergency_call" msgid="5347633784401285225">"Panggilan darurat"</string>
    <string name="lockscreen_return_to_call" msgid="5244259785500040021">"Kembali ke panggilan"</string>
    <string name="lockscreen_pattern_correct" msgid="9039008650362261237">"Perbaiki!"</string>
    <string name="lockscreen_pattern_wrong" msgid="4317955014948108794">"Coba lagi"</string>
    <string name="lockscreen_password_wrong" msgid="5737815393253165301">"Coba lagi"</string>
    <string name="faceunlock_multiple_failures" msgid="754137583022792429">"Percobaan Face Unlock melebihi batas maksimum"</string>
    <string name="lockscreen_plugged_in" msgid="8057762828355572315">"Mengisi daya, <xliff:g id="NUMBER">%d</xliff:g><xliff:g id="PERCENT">%%</xliff:g>"</string>
    <string name="lockscreen_charged" msgid="4938930459620989972">"Terisi."</string>
    <string name="lockscreen_battery_short" msgid="4477264849386850266">"<xliff:g id="NUMBER">%d</xliff:g><xliff:g id="PERCENT">%%</xliff:g>"</string>
    <string name="lockscreen_low_battery" msgid="1482873981919249740">"Hubungkan pengisi daya."</string>
    <string name="lockscreen_missing_sim_message_short" msgid="7381499217732227295">"Tidak ada kartu SIM."</string>
    <string name="lockscreen_missing_sim_message" product="tablet" msgid="151659196095791474">"Tidak ada kartu SIM dalam tablet."</string>
    <string name="lockscreen_missing_sim_message" product="default" msgid="2186920585695169078">"Tidak ada Kartu SIM di dalam ponsel."</string>
    <string name="lockscreen_missing_sim_instructions" msgid="5372787138023272615">"Masukkan kartu SIM."</string>
    <string name="lockscreen_missing_sim_instructions_long" msgid="3526573099019319472">"Kartu SIM tidak ada atau tidak dapat dibaca. Masukkan kartu SIM."</string>
    <string name="lockscreen_permanent_disabled_sim_message_short" msgid="5096149665138916184">"Kartu SIM tidak dapat digunakan."</string>
    <string name="lockscreen_permanent_disabled_sim_instructions" msgid="910904643433151371">"Kartu SIM Anda telah dinonaktifkan secara permanen."\n" Hubungi penyedia layanan nirkabel Anda untuk kartu SIM lain."</string>
    <string name="lockscreen_transport_prev_description" msgid="201594905152746886">"Tombol trek sebelumnya"</string>
    <string name="lockscreen_transport_next_description" msgid="6089297650481292363">"Tombol trek berikutnya"</string>
    <string name="lockscreen_transport_pause_description" msgid="7659088786780128001">"Tombol jeda"</string>
    <string name="lockscreen_transport_play_description" msgid="5888422938351019426">"Tombol putar"</string>
    <string name="lockscreen_transport_stop_description" msgid="4562318378766987601">"Tombol hentikan"</string>
    <string name="emergency_calls_only" msgid="6733978304386365407">"Panggilan darurat saja"</string>
    <string name="lockscreen_network_locked_message" msgid="143389224986028501">"Jaringan terkunci"</string>
    <string name="lockscreen_sim_puk_locked_message" msgid="7441797339976230">"Kartu SIM terkunci PUK."</string>
    <string name="lockscreen_sim_puk_locked_instructions" msgid="8127916255245181063">"Lihatlah Panduan Pengguna atau hubungi Layanan Pelanggan."</string>
    <string name="lockscreen_sim_locked_message" msgid="8066660129206001039">"Kartu SIM terkunci."</string>
    <string name="lockscreen_sim_unlock_progress_dialog_message" msgid="595323214052881264">"Membuka kartu SIM…"</string>
    <string name="lockscreen_too_many_failed_attempts_dialog_message" msgid="6481623830344107222">"Anda telah <xliff:g id="NUMBER_0">%d</xliff:g> kali salah menggambar pola pembuka kunci. "\n\n"Coba lagi dalam <xliff:g id="NUMBER_1">%d</xliff:g> detik."</string>
    <string name="lockscreen_too_many_failed_password_attempts_dialog_message" msgid="2725973286239344555">"Anda telah <xliff:g id="NUMBER_0">%d</xliff:g> kali salah mengetik sandi. "\n\n"Coba lagi dalam <xliff:g id="NUMBER_1">%d</xliff:g> detik."</string>
    <string name="lockscreen_too_many_failed_pin_attempts_dialog_message" msgid="6216672706545696955">"Anda telah <xliff:g id="NUMBER_0">%d</xliff:g> kali salah mengetik PIN. "\n\n"Coba lagi dalam <xliff:g id="NUMBER_1">%d</xliff:g> detik."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="tablet" msgid="9191611984625460820">"Anda telah <xliff:g id="NUMBER_0">%d</xliff:g> kali salah menggambar pola pembuka kunci. Setelah <xliff:g id="NUMBER_1">%d</xliff:g> lagi upaya gagal, Anda akan diminta membuka kunci tablet menggunakan info masuk Google."\n\n"Coba lagi dalam <xliff:g id="NUMBER_2">%d</xliff:g> detik."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="default" msgid="2590227559763762751">"Anda telah <xliff:g id="NUMBER_0">%d</xliff:g> kali salah menggambar pola pembuka kunci. Setelah <xliff:g id="NUMBER_1">%d</xliff:g> lagi upaya gagal, Anda akan diminta membuka kunci ponsel menggunakan info masuk Google."\n\n"Coba lagi dalam <xliff:g id="NUMBER_2">%d</xliff:g> detik."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="tablet" msgid="6128106399745755604">"Anda telah gagal mencoba membuka gembok tablet sebanyak <xliff:g id="NUMBER_0">%d</xliff:g> kali. Setelah <xliff:g id="NUMBER_1">%d</xliff:g> upaya gagal lagi, tablet akan disetel ulang ke setelan default pabrik dan semua data pengguna hilang."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="default" msgid="8603565142156826565">"Anda telah gagal mencoba membuka gembok ponsel sebanyak <xliff:g id="NUMBER_0">%d</xliff:g> kali. Setelah <xliff:g id="NUMBER_1">%d</xliff:g> upaya gagal lagi, ponsel akan disetel ulang ke setelan default pabrik dan semua data pengguna hilang."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="tablet" msgid="280873516493934365">"Anda telah gagal mencoba membuka gembok tablet sebanyak <xliff:g id="NUMBER">%d</xliff:g> kali. Kini tablet akan disetel ulang ke setelan default pabrik."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="default" msgid="3025504721764922246">"Anda telah gagal mencoba membuka gembok ponsel sebanyak <xliff:g id="NUMBER">%d</xliff:g> kali. Kini ponsel akan disetel ulang ke setelan default pabrik."</string>
    <string name="lockscreen_too_many_failed_attempts_countdown" msgid="6251480343394389665">"Coba lagi dalam <xliff:g id="NUMBER">%d</xliff:g> detik."</string>
    <string name="lockscreen_forgot_pattern_button_text" msgid="2626999449610695930">"Lupa pola?"</string>
    <string name="lockscreen_glogin_forgot_pattern" msgid="2588521501166032747">"Pembuka kunci akun"</string>
    <string name="lockscreen_glogin_too_many_attempts" msgid="2751368605287288808">"Terlalu banyak upaya pola"</string>
    <string name="lockscreen_glogin_instructions" msgid="3931816256100707784">"Untuk membuka, masuk dengan akun Google Anda."</string>
    <string name="lockscreen_glogin_username_hint" msgid="8846881424106484447">"Nama pengguna (email)"</string>
    <string name="lockscreen_glogin_password_hint" msgid="5958028383954738528">"Sandi"</string>
    <string name="lockscreen_glogin_submit_button" msgid="7130893694795786300">"Masuk"</string>
    <string name="lockscreen_glogin_invalid_input" msgid="1364051473347485908">"Nama pengguna atau sandi tidak valid."</string>
    <string name="lockscreen_glogin_account_recovery_hint" msgid="1696924763690379073">"Lupa nama pengguna atau sandi Anda?"\n"Kunjungi "<b>"google.com/accounts/recovery"</b>"."</string>
    <string name="lockscreen_glogin_checking_password" msgid="7114627351286933867">"Memeriksa..."</string>
    <string name="lockscreen_unlock_label" msgid="737440483220667054">"Buka kunci"</string>
    <string name="lockscreen_sound_on_label" msgid="9068877576513425970">"Suara hidup"</string>
    <string name="lockscreen_sound_off_label" msgid="996822825154319026">"Suara mati"</string>
    <string name="lockscreen_access_pattern_start" msgid="3941045502933142847">"Pola dimulai"</string>
    <string name="lockscreen_access_pattern_cleared" msgid="5583479721001639579">"Pola dihapus"</string>
    <string name="lockscreen_access_pattern_cell_added" msgid="6756031208359292487">"Sel ditambahkan"</string>
    <string name="lockscreen_access_pattern_detected" msgid="4988730895554057058">"Pola selesai"</string>
    <string name="password_keyboard_label_symbol_key" msgid="992280756256536042">"?123"</string>
    <string name="password_keyboard_label_alpha_key" msgid="8001096175167485649">"ABC"</string>
    <string name="password_keyboard_label_alt_key" msgid="1284820942620288678">"ALT"</string>
    <string name="granularity_label_character" msgid="7336470535385009523">"karakter"</string>
    <string name="granularity_label_word" msgid="7075570328374918660">"kata"</string>
    <string name="granularity_label_link" msgid="5815508880782488267">"tautan"</string>
    <string name="granularity_label_line" msgid="5764267235026120888">"baris"</string>
    <string name="hour_ampm" msgid="4584338083529355982">"<xliff:g id="HOUR">%-l</xliff:g><xliff:g id="AMPM">%P</xliff:g>"</string>
    <string name="hour_cap_ampm" msgid="2083465992940444366">"<xliff:g id="HOUR">%-l</xliff:g><xliff:g id="AMPM">%p</xliff:g>"</string>
    <string name="factorytest_failed" msgid="5410270329114212041">"Uji pabrik gagal"</string>
    <string name="factorytest_not_system" msgid="4435201656767276723">"Tindakan FACTORY_TEST hanya didukung untuk paket yang terpasang pada /system/app."</string>
    <string name="factorytest_no_action" msgid="872991874799998561">"Tidak ada paket yang memberikan tindakan FACTORY_TEST."</string>
    <string name="factorytest_reboot" msgid="6320168203050791643">"Mulai ulang"</string>
    <string name="js_dialog_title" msgid="1987483977834603872">"Laman pada \"<xliff:g id="TITLE">%s</xliff:g>\" menyatakan:"</string>
    <string name="js_dialog_title_default" msgid="6961903213729667573">"JavaScript"</string>
    <string name="js_dialog_before_unload" msgid="730366588032430474">"Beranjak dari laman ini?"\n\n"<xliff:g id="MESSAGE">%s</xliff:g>"\n\n"Sentuh Oke untuk melanjutkan atau Batal untuk tetap pada laman ini."</string>
    <string name="save_password_label" msgid="6860261758665825069">"Konfirmasi"</string>
    <string name="double_tap_toast" msgid="4595046515400268881">"Kiat: Ketuk dua kali untuk memperbesar dan memperkecil."</string>
    <string name="autofill_this_form" msgid="4616758841157816676">"Isiotomatis"</string>
    <string name="setup_autofill" msgid="7103495070180590814">"Siapkan Pengisian Otomatis"</string>
    <string name="autofill_address_name_separator" msgid="6350145154779706772">"  "</string>
    <string name="autofill_address_summary_name_format" msgid="3268041054899214945">"$1$2$3"</string>
    <string name="autofill_address_summary_separator" msgid="7483307893170324129">", "</string>
    <string name="autofill_address_summary_format" msgid="4874459455786827344">"$1$2$3"</string>
    <string name="autofill_province" msgid="2231806553863422300">"Provinsi"</string>
    <string name="autofill_postal_code" msgid="4696430407689377108">"Kode pos"</string>
    <string name="autofill_state" msgid="6988894195520044613">"Negara Bagian"</string>
    <string name="autofill_zip_code" msgid="8697544592627322946">"Kode pos"</string>
    <string name="autofill_county" msgid="237073771020362891">"Wilayah"</string>
    <string name="autofill_island" msgid="4020100875984667025">"Pulau"</string>
    <string name="autofill_district" msgid="8400735073392267672">"Distrik"</string>
    <string name="autofill_department" msgid="5343279462564453309">"Departemen"</string>
    <string name="autofill_prefecture" msgid="2028499485065800419">"Prefektur"</string>
    <string name="autofill_parish" msgid="8202206105468820057">"Kampung"</string>
    <string name="autofill_area" msgid="3547409050889952423">"Area"</string>
    <string name="autofill_emirate" msgid="2893880978835698818">"Emirat"</string>
    <string name="permlab_readHistoryBookmarks" msgid="3775265775405106983">"baca riwayat dan bookmark web Anda"</string>
    <string name="permdesc_readHistoryBookmarks" msgid="8462378226600439658">"Memungkinkan aplikasi membaca riwayat semua URL yang telah dikunjungi Browser, dan semua bookmark Browser. Catatan: izin ini tidak dapat diberlakukan oleh browser pihak ketiga atau aplikasi lain dengan kemampuan menjelajahi web."</string>
    <string name="permlab_writeHistoryBookmarks" msgid="3714785165273314490">"tulis riwayat dan bookmark web"</string>
    <string name="permdesc_writeHistoryBookmarks" product="tablet" msgid="6825527469145760922">"Memungkinkan aplikasi mengubah riwayat atau bookmark Browser yang tersimpan dalam tablet Anda. Izin ini memungkinkan aplikasi menghapus atau mengubah data Browser. Catatan: izin ini tidak dapat diberlakukan oleh browser pihak ketiga atau aplikasi lain dengan kemampuan menjelajahi web."</string>
    <string name="permdesc_writeHistoryBookmarks" product="default" msgid="8497389531014185509">"Memungkinkan aplikasi mengubah riwayat atau bookmark Browser yang tersimpan dalam ponsel Anda. Izin ini memungkinkan aplikasi menghapus atau mengubah data Browser. Catatan: izin ini tidak dapat diberlakukan oleh browser pihak ketiga atau aplikasi lain dengan kemampuan menjelajahi web."</string>
    <string name="permlab_setAlarm" msgid="1379294556362091814">"setel alarm"</string>
    <string name="permdesc_setAlarm" msgid="316392039157473848">"Mengizinkan apl menyetel alarm di apl jam alarm yang terpasang. Beberapa apl jam alarm mungkin tidak menerapkan fitur ini."</string>
    <string name="permlab_addVoicemail" msgid="5525660026090959044">"tambahkan kotak pesan"</string>
    <string name="permdesc_addVoicemail" msgid="6604508651428252437">"Mengizinkan apl menambahkan pesan ke kotak masuk untuk pesan suara Anda."</string>
    <string name="permlab_writeGeolocationPermissions" msgid="5962224158955273932">"memodifikasi izin geolokasi Browser"</string>
    <string name="permdesc_writeGeolocationPermissions" msgid="1083743234522638747">"Mengizinkan apl memodifikasi izin geolokasi Browser. Apl berbahaya dapat menggunakan izin ini untuk memungkinkan pengiriman informasi lokasi ke sembarang situs web."</string>
    <string name="permlab_packageVerificationAgent" msgid="5568139100645829117">"verifikasi paket"</string>
    <string name="permdesc_packageVerificationAgent" msgid="8437590190990843381">"Mengizinkan apl memverifikasi bahwa suatu paket dapat dipasang."</string>
    <string name="permlab_bindPackageVerifier" msgid="4187786793360326654">"mengikat ke pemverifikasi paket"</string>
    <string name="permdesc_bindPackageVerifier" msgid="3180741773233862126">"Mengizinkan pemegang mengajukan permintaan pemverifikasian paket. Tidak pernah dibutuhkan oleh apl normal."</string>
    <string name="permlab_serialPort" msgid="546083327654631076">"akses port serial"</string>
    <string name="permdesc_serialPort" msgid="2991639985224598193">"Memungkinkan pemegangnya mengakses port serial menggunakan API SerialManager."</string>
    <string name="permlab_accessContentProvidersExternally" msgid="5077774297943409285">"mengakses penyedia konten dari luar"</string>
    <string name="permdesc_accessContentProvidersExternally" msgid="4544346486697853685">"Memungkinkan pemegang mengakses penyedia konten dari cangkang. Tidak pernah diperlukan untuk apl normal."</string>
    <string name="permlab_updateLock" msgid="3527558366616680889">"menghindari pembaruan perangkat otomatis"</string>
    <string name="permdesc_updateLock" msgid="1655625832166778492">"Memungkinkan pemegang untuk menawarkan informasi ke sistem mengenai kapan waktu yang baik bagi pemulaian ulang non-interaktif untuk meningkatkan versi perangkat."</string>
    <string name="save_password_message" msgid="767344687139195790">"Apakah Anda ingin browser menyimpan sandi ini?"</string>
    <string name="save_password_notnow" msgid="6389675316706699758">"Tidak sekarang"</string>
    <string name="save_password_remember" msgid="6491879678996749466">"Ingat"</string>
    <string name="save_password_never" msgid="8274330296785855105">"Jangan"</string>
    <string name="open_permission_deny" msgid="7374036708316629800">"Anda tidak memiliki izin untuk membuka laman ini."</string>
    <string name="text_copied" msgid="4985729524670131385">"Teks disalin ke clipboard."</string>
    <string name="more_item_label" msgid="4650918923083320495">"Lainnya"</string>
    <string name="prepend_shortcut_label" msgid="2572214461676015642">"Menu+"</string>
    <string name="menu_space_shortcut_label" msgid="2410328639272162537">"spasi"</string>
    <string name="menu_enter_shortcut_label" msgid="2743362785111309668">"enter"</string>
    <string name="menu_delete_shortcut_label" msgid="3658178007202748164">"hapus"</string>
    <string name="search_go" msgid="8298016669822141719">"Telusuri"</string>
    <string name="searchview_description_search" msgid="6749826639098512120">"Penelusuran"</string>
    <string name="searchview_description_query" msgid="5911778593125355124">"Kueri penelusuran"</string>
    <string name="searchview_description_clear" msgid="1330281990951833033">"Hapus kueri"</string>
    <string name="searchview_description_submit" msgid="2688450133297983542">"Mengirimkan kueri"</string>
    <string name="searchview_description_voice" msgid="2453203695674994440">"Penelusuran suara"</string>
    <string name="enable_explore_by_touch_warning_title" msgid="7460694070309730149">"Aktifkan Menjelajah dengan Sentuhan?"</string>
    <string name="enable_explore_by_touch_warning_message" product="tablet" msgid="8655887539089910577">"<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> ingin mengaktifkan Menjelajah dengan Sentuhan. Saat Menjelajah dengan Sentuhan diaktifkan, Anda dapat melihat atau mendengar deskripsi dari apa yang ada di bawah jari Anda atau melakukan gerakan untuk berinteraksi dengan tablet."</string>
    <string name="enable_explore_by_touch_warning_message" product="default" msgid="2708199672852373195">"<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> ingin mengaktifkan Menjelajah dengan Sentuhan. Saat Menjelajah dengan Sentuhan diaktifkan, Anda dapat mendengar atau melihat deskripsi dari apa yang ada di bawah jari Anda atau melakukan gerakan untuk berinteraksi dengan ponsel."</string>
    <string name="oneMonthDurationPast" msgid="7396384508953779925">"1 bulan yang lalu"</string>
    <string name="beforeOneMonthDurationPast" msgid="909134546836499826">"Sebelum 1 bulan yang lalu"</string>
  <plurals name="num_seconds_ago">
    <item quantity="one" msgid="4869870056547896011">"1 detik lalu"</item>
    <item quantity="other" msgid="3903706804349556379">"<xliff:g id="COUNT">%d</xliff:g> detik yang lalu"</item>
  </plurals>
  <plurals name="num_minutes_ago">
    <item quantity="one" msgid="3306787433088810191">"1 menit yang lalu"</item>
    <item quantity="other" msgid="2176942008915455116">"<xliff:g id="COUNT">%d</xliff:g> menit yang lalu"</item>
  </plurals>
  <plurals name="num_hours_ago">
    <item quantity="one" msgid="9150797944610821849">"1 jam yang lalu"</item>
    <item quantity="other" msgid="2467273239587587569">"<xliff:g id="COUNT">%d</xliff:g> jam yang lalu"</item>
  </plurals>
  <plurals name="last_num_days">
    <item quantity="other" msgid="3069992808164318268">"<xliff:g id="COUNT">%d</xliff:g> hari terakhir"</item>
  </plurals>
    <string name="last_month" msgid="3959346739979055432">"Bulan lalu"</string>
    <string name="older" msgid="5211975022815554840">"Lawas"</string>
  <plurals name="num_days_ago">
    <item quantity="one" msgid="861358534398115820">"kemarin"</item>
    <item quantity="other" msgid="2479586466153314633">"<xliff:g id="COUNT">%d</xliff:g> hari yang lalu"</item>
  </plurals>
  <plurals name="in_num_seconds">
    <item quantity="one" msgid="2729745560954905102">"dalam 1 detik"</item>
    <item quantity="other" msgid="1241926116443974687">"dalam <xliff:g id="COUNT">%d</xliff:g> detik"</item>
  </plurals>
  <plurals name="in_num_minutes">
    <item quantity="one" msgid="8793095251325200395">"dalam 1 menit"</item>
    <item quantity="other" msgid="3330713936399448749">"dalam <xliff:g id="COUNT">%d</xliff:g> menit"</item>
  </plurals>
  <plurals name="in_num_hours">
    <item quantity="one" msgid="7164353342477769999">"dalam 1 jam"</item>
    <item quantity="other" msgid="547290677353727389">"dalam <xliff:g id="COUNT">%d</xliff:g> jam"</item>
  </plurals>
  <plurals name="in_num_days">
    <item quantity="one" msgid="5413088743009839518">"besok"</item>
    <item quantity="other" msgid="5109449375100953247">"dalam <xliff:g id="COUNT">%d</xliff:g> hari"</item>
  </plurals>
  <plurals name="abbrev_num_seconds_ago">
    <item quantity="one" msgid="1849036840200069118">"1 detik yang lalu"</item>
    <item quantity="other" msgid="3699169366650930415">"<xliff:g id="COUNT">%d</xliff:g> detik yang lalu"</item>
  </plurals>
  <plurals name="abbrev_num_minutes_ago">
    <item quantity="one" msgid="6361490147113871545">"1 menit yang lalu"</item>
    <item quantity="other" msgid="851164968597150710">"<xliff:g id="COUNT">%d</xliff:g> menit yang lalu"</item>
  </plurals>
  <plurals name="abbrev_num_hours_ago">
    <item quantity="one" msgid="4796212039724722116">"1 jam yang lalu"</item>
    <item quantity="other" msgid="6889970745748538901">"<xliff:g id="COUNT">%d</xliff:g> jam yang lalu"</item>
  </plurals>
  <plurals name="abbrev_num_days_ago">
    <item quantity="one" msgid="8463161711492680309">"kemarin"</item>
    <item quantity="other" msgid="3453342639616481191">"<xliff:g id="COUNT">%d</xliff:g> hari yang lalu"</item>
  </plurals>
  <plurals name="abbrev_in_num_seconds">
    <item quantity="one" msgid="5842225370795066299">"dalam 1 detik"</item>
    <item quantity="other" msgid="5495880108825805108">"dalam <xliff:g id="COUNT">%d</xliff:g> detik"</item>
  </plurals>
  <plurals name="abbrev_in_num_minutes">
    <item quantity="one" msgid="562786149928284878">"dalam 1 menit"</item>
    <item quantity="other" msgid="4216113292706568726">"dalam <xliff:g id="COUNT">%d</xliff:g> menit"</item>
  </plurals>
  <plurals name="abbrev_in_num_hours">
    <item quantity="one" msgid="3274708118124045246">"dalam 1 jam"</item>
    <item quantity="other" msgid="3705373766798013406">"dalam <xliff:g id="COUNT">%d</xliff:g> jam"</item>
  </plurals>
  <plurals name="abbrev_in_num_days">
    <item quantity="one" msgid="2178576254385739855">"besok"</item>
    <item quantity="other" msgid="2973062968038355991">"dalam <xliff:g id="COUNT">%d</xliff:g> hari"</item>
  </plurals>
    <string name="preposition_for_date" msgid="9093949757757445117">"pada <xliff:g id="DATE">%s</xliff:g>"</string>
    <string name="preposition_for_time" msgid="5506831244263083793">"pada <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="preposition_for_year" msgid="5040395640711867177">"dalam <xliff:g id="YEAR">%s</xliff:g>"</string>
    <string name="day" msgid="8144195776058119424">"hari"</string>
    <string name="days" msgid="4774547661021344602">"hari"</string>
    <string name="hour" msgid="2126771916426189481">"jam"</string>
    <string name="hours" msgid="894424005266852993">"jam"</string>
    <string name="minute" msgid="9148878657703769868">"menit"</string>
    <string name="minutes" msgid="5646001005827034509">"menit"</string>
    <string name="second" msgid="3184235808021478">"detik"</string>
    <string name="seconds" msgid="3161515347216589235">"detik"</string>
    <string name="week" msgid="5617961537173061583">"minggu"</string>
    <string name="weeks" msgid="6509623834583944518">"minggu"</string>
    <string name="year" msgid="4001118221013892076">"tahun"</string>
    <string name="years" msgid="6881577717993213522">"tahun"</string>
    <string name="VideoView_error_title" msgid="3534509135438353077">"Masalah video"</string>
    <string name="VideoView_error_text_invalid_progressive_playback" msgid="3186670335938670444">"Video ini tidak valid untuk pengaliran ke perangkat ini."</string>
    <string name="VideoView_error_text_unknown" msgid="3450439155187810085">"Tidak dapat memutar video ini."</string>
    <string name="VideoView_error_button" msgid="2822238215100679592">"Oke"</string>
    <string name="relative_time" msgid="1818557177829411417">"<xliff:g id="DATE">%1$s</xliff:g>, <xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="noon" msgid="7245353528818587908">"tengah hari"</string>
    <string name="Noon" msgid="3342127745230013127">"Tengah hari"</string>
    <string name="midnight" msgid="7166259508850457595">"tengah malam"</string>
    <string name="Midnight" msgid="5630806906897892201">"Tengah malam"</string>
    <string name="elapsed_time_short_format_mm_ss" msgid="4431555943828711473">"<xliff:g id="MINUTES">%1$02d</xliff:g>.<xliff:g id="SECONDS">%2$02d</xliff:g>"</string>
    <string name="elapsed_time_short_format_h_mm_ss" msgid="1846071997616654124">"<xliff:g id="HOURS">%1$d</xliff:g>.<xliff:g id="MINUTES">%2$02d</xliff:g>.<xliff:g id="SECONDS">%3$02d</xliff:g>"</string>
    <string name="selectAll" msgid="6876518925844129331">"Pilih semua"</string>
    <string name="cut" msgid="3092569408438626261">"Potong"</string>
    <string name="copy" msgid="2681946229533511987">"Salin"</string>
    <string name="paste" msgid="5629880836805036433">"Tempel"</string>
    <string name="replace" msgid="5781686059063148930">"Ganti..."</string>
    <string name="delete" msgid="6098684844021697789">"Hapus"</string>
    <string name="copyUrl" msgid="2538211579596067402">"Salin URL"</string>
    <string name="selectTextMode" msgid="1018691815143165326">"Pilih teks"</string>
    <string name="textSelectionCABTitle" msgid="5236850394370820357">"Pemilihan teks"</string>
    <string name="addToDictionary" msgid="9090375111134433012">"tambahkan ke kamus"</string>
    <string name="deleteText" msgid="7070985395199629156">"hapus"</string>
    <string name="inputMethod" msgid="1653630062304567879">"Metode masukan"</string>
    <string name="editTextMenuTitle" msgid="4909135564941815494">"Tindakan teks"</string>
    <string name="low_internal_storage_view_title" msgid="5576272496365684834">"Ruang penyimpanan hampir habis"</string>
    <string name="low_internal_storage_view_text" msgid="6640505817617414371">"Beberapa fungsi sistem mungkin tidak dapat bekerja"</string>
    <string name="ok" msgid="5970060430562524910">"Oke"</string>
    <string name="cancel" msgid="6442560571259935130">"Batal"</string>
    <string name="yes" msgid="5362982303337969312">"Oke"</string>
    <string name="no" msgid="5141531044935541497">"Batal"</string>
    <string name="dialog_alert_title" msgid="2049658708609043103">"Perhatian"</string>
    <string name="loading" msgid="7933681260296021180">"Memuat..."</string>
    <string name="capital_on" msgid="1544682755514494298">"HIDUP"</string>
    <string name="capital_off" msgid="6815870386972805832">"MATI"</string>
    <string name="whichApplication" msgid="4533185947064773386">"Tindakan lengkap menggunakan"</string>
    <string name="alwaysUse" msgid="4583018368000610438">"Gunakan secara default untuk tindakan ini."</string>
    <string name="clearDefaultHintMsg" msgid="3252584689512077257">"Menghapus default di Setelan sistem &gt; Apl &gt; Terunduh."</string>
    <string name="chooseActivity" msgid="7486876147751803333">"Pilih tindakan"</string>
    <string name="chooseUsbActivity" msgid="6894748416073583509">"Pilih apl untuk perangkat USB"</string>
    <string name="noApplications" msgid="2991814273936504689">"Tidak ada apl yang dapat melakukan tindakan ini."</string>
    <string name="aerr_title" msgid="1905800560317137752"></string>
    <string name="aerr_application" msgid="932628488013092776">"Sayangnya, <xliff:g id="APPLICATION">%1$s</xliff:g> telah berhenti."</string>
    <string name="aerr_process" msgid="4507058997035697579">"Sayangnya, proses <xliff:g id="PROCESS">%1$s</xliff:g> telah berhenti."</string>
    <string name="anr_title" msgid="4351948481459135709"></string>
    <string name="anr_activity_application" msgid="1904477189057199066">"<xliff:g id="APPLICATION">%2$s</xliff:g> tidak menanggapi."\n\n"Anda ingin menutupnya?"</string>
    <string name="anr_activity_process" msgid="5776209883299089767">"Aktivitas <xliff:g id="ACTIVITY">%1$s</xliff:g> tidak menanggapi."\n\n"Anda ingin menutupnya?"</string>
    <string name="anr_application_process" msgid="8941757607340481057">"<xliff:g id="APPLICATION">%1$s</xliff:g> tidak menanggapi. Anda ingin menutupnya?"</string>
    <string name="anr_process" msgid="6513209874880517125">"Proses <xliff:g id="PROCESS">%1$s</xliff:g> tidak menanggapi."\n\n"Anda ingin menutupnya?"</string>
    <string name="force_close" msgid="8346072094521265605">"Oke"</string>
    <string name="report" msgid="4060218260984795706">"Laporkan"</string>
    <string name="wait" msgid="7147118217226317732">"Tunggu"</string>
    <string name="webpage_unresponsive" msgid="3272758351138122503">"Laman ini tidak menanggapi."\n\n"Apakah Anda ingin menutupnya?"</string>
    <string name="launch_warning_title" msgid="1547997780506713581">"Apl dialihkan"</string>
    <string name="launch_warning_replace" msgid="6202498949970281412">"<xliff:g id="APP_NAME">%1$s</xliff:g> sedang berjalan."</string>
    <string name="launch_warning_original" msgid="188102023021668683">"<xliff:g id="APP_NAME">%1$s</xliff:g> telah diluncurkan aslinya."</string>
    <string name="screen_compat_mode_scale" msgid="3202955667675944499">"Skala"</string>
    <string name="screen_compat_mode_show" msgid="4013878876486655892">"Selalu tampilkan"</string>
    <string name="screen_compat_mode_hint" msgid="1064524084543304459">"Aktifkan kembali dialog ini di Setelan sistem &gt; Apl &gt; Terunduh."</string>
    <string name="smv_application" msgid="3307209192155442829">"Apl <xliff:g id="APPLICATION">%1$s</xliff:g> (proses <xliff:g id="PROCESS">%2$s</xliff:g>) telah melanggar kebijakan StrictMode yang diberlakukannya sendiri."</string>
    <string name="smv_process" msgid="5120397012047462446">"Proses <xliff:g id="PROCESS">%1$s</xliff:g> telah melanggar kebijakan StrictMode yang diberlakukan secara otomatis."</string>
    <string name="android_upgrading_title" msgid="1584192285441405746">"Android sedang meningkatkan versi..."</string>
    <string name="android_upgrading_apk" msgid="7904042682111526169">"Mengoptimalkan apl <xliff:g id="NUMBER_0">%1$d</xliff:g> dari <xliff:g id="NUMBER_1">%2$d</xliff:g>."</string>
    <string name="android_upgrading_starting_apps" msgid="451464516346926713">"Memulai apl."</string>
    <string name="android_upgrading_complete" msgid="1405954754112999229">"Menyelesaikan boot."</string>
    <string name="heavy_weight_notification" msgid="9087063985776626166">"<xliff:g id="APP">%1$s</xliff:g> berjalan"</string>
    <string name="heavy_weight_notification_detail" msgid="1721681741617898865">"Sentuh untuk beralih ke apl"</string>
    <string name="heavy_weight_switcher_title" msgid="7153167085403298169">"Beralih apl?"</string>
    <string name="heavy_weight_switcher_text" msgid="7022631924534406403">"Apl lain sudah berjalan dan harus dihentikan agar Anda dapat memulai yang baru."</string>
    <string name="old_app_action" msgid="493129172238566282">"Kembali ke<xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="old_app_description" msgid="2082094275580358049">"Jangan memulai apl baru."</string>
    <string name="new_app_action" msgid="5472756926945440706">"Mulai <xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="new_app_description" msgid="1932143598371537340">"Hentikan apl lama tanpa menyimpan."</string>
    <string name="sendText" msgid="5209874571959469142">"Pilih tindakan untuk teks"</string>
    <string name="volume_ringtone" msgid="6885421406845734650">"Volume dering"</string>
    <string name="volume_music" msgid="5421651157138628171">"Volume media"</string>
    <string name="volume_music_hint_playing_through_bluetooth" msgid="9165984379394601533">"Memutar melalui Bluetooth"</string>
    <string name="volume_music_hint_silent_ringtone_selected" msgid="8310739960973156272">"Nada dering senyap disetel"</string>
    <string name="volume_call" msgid="3941680041282788711">"Volume saat-memanggil"</string>
    <string name="volume_bluetooth_call" msgid="2002891926351151534">"Volume saat-memanggil bluetooth"</string>
    <string name="volume_alarm" msgid="1985191616042689100">"Volume alarm"</string>
    <string name="volume_notification" msgid="2422265656744276715">"Volume pemberitahuan"</string>
    <string name="volume_unknown" msgid="1400219669770445902">"Volume"</string>
    <string name="volume_icon_description_bluetooth" msgid="6538894177255964340">"Volume bluetooth"</string>
    <string name="volume_icon_description_ringer" msgid="3326003847006162496">"Volume nada dering"</string>
    <string name="volume_icon_description_incall" msgid="8890073218154543397">"Volume panggilan"</string>
    <string name="volume_icon_description_media" msgid="4217311719665194215">"Volume media"</string>
    <string name="volume_icon_description_notification" msgid="7044986546477282274">"Volume pemberitahuan"</string>
    <string name="ringtone_default" msgid="3789758980357696936">"Nada dering default"</string>
    <string name="ringtone_default_with_actual" msgid="8129563480895990372">"Nada dering default (<xliff:g id="ACTUAL_RINGTONE">%1$s</xliff:g>)"</string>
    <string name="ringtone_silent" msgid="4440324407807468713">"Senyap"</string>
    <string name="ringtone_picker_title" msgid="3515143939175119094">"Nada dering"</string>
    <string name="ringtone_unknown" msgid="5477919988701784788">"Nada dering tidak dikenal"</string>
  <plurals name="wifi_available">
    <item quantity="one" msgid="6654123987418168693">"Jaringan Wi-Fi tersedia"</item>
    <item quantity="other" msgid="4192424489168397386">"Jaringan Wi-Fi"</item>
  </plurals>
  <plurals name="wifi_available_detailed">
    <item quantity="one" msgid="1634101450343277345">"Jaringan Wi-Fi terbuka tersedia"</item>
    <item quantity="other" msgid="7915895323644292768">"Jaringan Wi-Fi terbuka tersedia"</item>
  </plurals>
    <string name="wifi_available_sign_in" msgid="4029489716605255386">"Masuk ke jaringan Wi-Fi"</string>
    <!-- no translation found for wifi_available_sign_in_detailed (6797764740339907572) -->
    <skip />
    <string name="wifi_watchdog_network_disabled" msgid="7904214231651546347">"Tidak dapat tersambung ke Wi-Fi"</string>
    <string name="wifi_watchdog_network_disabled_detailed" msgid="5548780776418332675">" memiliki sambungan internet yang buruk."</string>
    <string name="wifi_p2p_dialog_title" msgid="97611782659324517">"Wi-Fi Langsung"</string>
    <string name="wifi_p2p_turnon_message" msgid="2909250942299627244">"Memulai Wi-Fi Langsung. Opsi ini akan mematikan hotspot/klien Wi-Fi."</string>
    <string name="wifi_p2p_failed_message" msgid="3763669677935623084">"Tidak dapat memulai Wi-Fi Langsung."</string>
    <string name="wifi_p2p_enabled_notification_title" msgid="2068321881673734886">"Wi-Fi Langsung aktif"</string>
    <string name="wifi_p2p_enabled_notification_message" msgid="1638949953993894335">"Sentuh untuk setelan"</string>
    <string name="accept" msgid="1645267259272829559">"Terima"</string>
    <string name="decline" msgid="2112225451706137894">"Tolak"</string>
    <string name="wifi_p2p_invitation_sent_title" msgid="1318975185112070734">"Undangan terkirim"</string>
    <string name="wifi_p2p_invitation_to_connect_title" msgid="4958803948658533637">"Undangan untuk terhubung"</string>
    <string name="wifi_p2p_from_message" msgid="570389174731951769">"Dari:"</string>
    <string name="wifi_p2p_to_message" msgid="248968974522044099">"Kepada:"</string>
    <string name="wifi_p2p_enter_pin_message" msgid="5920929550367828970">"Ketik PIN yang diminta:"</string>
    <string name="wifi_p2p_show_pin_message" msgid="8530563323880921094">"PIN:"</string>
    <string name="select_character" msgid="3365550120617701745">"Sisipkan huruf"</string>
    <string name="sms_control_title" msgid="7296612781128917719">"Mengirim pesan SMS"</string>
    <string name="sms_control_message" msgid="3867899169651496433">"&lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; sedang mengirim pesan SMS dalam jumlah besar. Izinkan aplikasi ini untuk melanjutkan pengiriman pesan?"</string>
    <string name="sms_control_yes" msgid="3663725993855816807">"Izinkan"</string>
    <string name="sms_control_no" msgid="625438561395534982">"Tolak"</string>
    <string name="sim_removed_title" msgid="6227712319223226185">"Kartu SIM dihapus"</string>
    <string name="sim_removed_message" msgid="2333164559970958645">"Jaringan seluler tidak akan tersedia sampai Anda memulai lagi dengan memasukkan kartu SIM yang valid."</string>
    <string name="sim_done_button" msgid="827949989369963775">"Selesai"</string>
    <string name="sim_added_title" msgid="3719670512889674693">"Kartu SIM ditambahkan"</string>
    <string name="sim_added_message" msgid="6599945301141050216">"Mulai ulang perangkat Anda untuk mengakses jaringan selular."</string>
    <string name="sim_restart_button" msgid="4722407842815232347">"Mulai Ulang"</string>
    <string name="time_picker_dialog_title" msgid="8349362623068819295">"Setel waktu"</string>
    <string name="date_picker_dialog_title" msgid="5879450659453782278">"Setel tanggal"</string>
    <string name="date_time_set" msgid="5777075614321087758">"Setel"</string>
    <string name="date_time_done" msgid="2507683751759308828">"Selesai"</string>
    <string name="default_permission_group" msgid="2690160991405646128">"Default"</string>
    <string name="no_permissions" msgid="7283357728219338112">"Tidak perlu izin"</string>
    <string name="perms_hide" msgid="7283915391320676226"><b>"Sembunyikan"</b></string>
    <string name="perms_show_all" msgid="2671791163933091180"><b>"Tampilkan semua"</b></string>
    <string name="perms_new_perm_prefix" msgid="8257740710754301407"><font size="12" fgcolor="#ff900000">"BARU: "</font></string>
    <string name="perms_description_app" msgid="5139836143293299417">"Disediakan oleh <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="usb_storage_activity_title" msgid="4465055157209648641">"Penyimpanan massal USB"</string>
    <string name="usb_storage_title" msgid="5901459041398751495">"USB terhubung"</string>
    <string name="usb_storage_message" product="nosdcard" msgid="3308538094316477839">"Anda telah tersambung ke komputer melalui USB. Sentuh tombol di bawah jika Anda ingin menyalin file antara komputer dan penyimpanan USB Android Anda."</string>
    <string name="usb_storage_message" product="default" msgid="805351000446037811">"Anda telah tersambung ke komputer melalui USB. Sentuh tombol di bawah jika Anda ingin menyalin file antara komputer dan kartu SD Android Anda."</string>
    <string name="usb_storage_button_mount" msgid="1052259930369508235">"Hidupkan penyimpanan USB"</string>
    <string name="usb_storage_error_message" product="nosdcard" msgid="3017045217365540658">"Terjadi masalah saat menggunakan penyimpanan USB Anda untuk penyimpanan massal USB."</string>
    <string name="usb_storage_error_message" product="default" msgid="2876018512716970313">"Terjadi masalah saat menggunakan kartu SD Anda untuk penyimpanan massal USB."</string>
    <string name="usb_storage_notification_title" msgid="8175892554757216525">"USB terhubung"</string>
    <string name="usb_storage_notification_message" msgid="939822783828183763">"Sentuh untuk menyalin file ke/dari komputer Anda."</string>
    <string name="usb_storage_stop_notification_title" msgid="2336058396663516017">"Matikan penyimpanan USB"</string>
    <string name="usb_storage_stop_notification_message" msgid="1656852098555623822">"Sentuh untuk mematikan penyimpanan USB."</string>
    <string name="usb_storage_stop_title" msgid="660129851708775853">"Penyimpanan USB sedang digunakan"</string>
    <string name="usb_storage_stop_message" product="nosdcard" msgid="4264025280777219521">"Sebelum mematikan penyimpanan USB, lepaskan (\"keluarkan\") penyimpanan USB Anda dari komputer."</string>
    <string name="usb_storage_stop_message" product="default" msgid="8043969782460613114">"Sebelum mematikan penyimpanan USB, lepaskan (\"keluarkan\") kartu SD Android dari komputer."</string>
    <string name="usb_storage_stop_button_mount" msgid="7060218034900696029">"Matikan penyimpanan USB"</string>
    <string name="usb_storage_stop_error_message" msgid="1970374898263063836">"Terjadi masalah saat mematikan penyimpanan USB. Periksa apakah Anda telah melepaskan host USB, lalu coba sekali lagi."</string>
    <string name="dlg_confirm_kill_storage_users_title" msgid="963039033470478697">"Hidupkan penyimpanan USB"</string>
    <string name="dlg_confirm_kill_storage_users_text" msgid="5100428757107469454">"Jika Anda menyalakan penyimpanan USB, beberapa apl yang Anda gunakan akan berhenti dan mungkin tidak dapat dibuka hingga penyimpanan USB dimatikan."</string>
    <string name="dlg_error_title" msgid="7323658469626514207">"Operasi USB gagal"</string>
    <string name="dlg_ok" msgid="7376953167039865701">"Oke"</string>
    <string name="usb_mtp_notification_title" msgid="3699913097391550394">"Tersambung sebagai perangkat media"</string>
    <string name="usb_ptp_notification_title" msgid="1960817192216064833">"Tersambung sebagai kamera"</string>
    <string name="usb_cd_installer_notification_title" msgid="6774712827892090754">"Tersambung sebagai pemasang"</string>
    <string name="usb_accessory_notification_title" msgid="7848236974087653666">"Tersambung ke aksesori USB"</string>
    <string name="usb_notification_message" msgid="2290859399983720271">"Sentuh untuk opsi USB lainnya."</string>
    <string name="extmedia_format_title" product="nosdcard" msgid="9020092196061007262">"Format penyimpanan USB?"</string>
    <string name="extmedia_format_title" product="default" msgid="3648415921526526069">"Format kartu SD?"</string>
    <string name="extmedia_format_message" product="nosdcard" msgid="3934016853425761078">"Semua file yang tersimpan dalam penyimpanan USB Anda akan dihapus. Tindakan ini tidak dapat diurungkan!"</string>
    <string name="extmedia_format_message" product="default" msgid="14131895027543830">"Semua data di kartu Anda akan hilang."</string>
    <string name="extmedia_format_button_format" msgid="4131064560127478695">"Format"</string>
    <string name="adb_active_notification_title" msgid="6729044778949189918">"Debugging USB terhubung"</string>
    <string name="adb_active_notification_message" msgid="1016654627626476142">"Sentuh untuk menonaktifkan debugging USB."</string>
    <string name="select_input_method" msgid="4653387336791222978">"Pilih metode masukan"</string>
    <string name="configure_input_methods" msgid="9091652157722495116">"Menyiapkan metode masukan"</string>
    <string name="use_physical_keyboard" msgid="6203112478095117625">"Keyboard fisik"</string>
    <string name="hardware" msgid="7517821086888990278">"Perangkat Keras"</string>
    <string name="select_keyboard_layout_notification_title" msgid="1407367017263030773">"Pilih tata letak keyboard"</string>
    <string name="select_keyboard_layout_notification_message" msgid="4465907700449257063">"Sentuh untuk memilih tata letak keyboard."</string>
    <string name="fast_scroll_alphabet" msgid="5433275485499039199">" ABCDEFGHIJKLMNOPQRSTUVWXYZ"</string>
    <string name="fast_scroll_numeric_alphabet" msgid="4030170524595123610">" 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"</string>
    <string name="candidates_style" msgid="4333913089637062257"><u>"calon"</u></string>
    <string name="ext_media_checking_notification_title" product="nosdcard" msgid="3449816005351468560">"Menyiapkan penyimpanan USB"</string>
    <string name="ext_media_checking_notification_title" product="default" msgid="5457603418970994050">"Menyiapkan kartu SD"</string>
    <string name="ext_media_checking_notification_message" msgid="8287319882926737053">"Memeriksa kesalahan."</string>
    <string name="ext_media_nofs_notification_title" product="nosdcard" msgid="7788040745686229307">"Penyimpanan USB kosong"</string>
    <string name="ext_media_nofs_notification_title" product="default" msgid="780477838241212997">"Kartu SD kosong"</string>
    <string name="ext_media_nofs_notification_message" product="nosdcard" msgid="7840121067427269500">"Penyimpanan USB kosong atau sistem berkasnya tidak didukung."</string>
    <string name="ext_media_nofs_notification_message" product="default" msgid="8641065641786923604">"Kartu SD kosong atau memiliki sistem file yang tidak didukung."</string>
    <string name="ext_media_unmountable_notification_title" product="nosdcard" msgid="2090046769532713563">"Penyimpanan USB rusak"</string>
    <string name="ext_media_unmountable_notification_title" product="default" msgid="6410723906019100189">"Kartu SD rusak"</string>
    <string name="ext_media_unmountable_notification_message" product="nosdcard" msgid="1795917578395333280">"Penyimpanan USB rusak. Coba diformat ulang."</string>
    <string name="ext_media_unmountable_notification_message" product="default" msgid="1753898567525568253">"Kartu SD rusak. Coba diformat ulang."</string>
    <string name="ext_media_badremoval_notification_title" product="nosdcard" msgid="1661683031330951073">"Penyimpanan USB dilepas secara tidak sengaja"</string>
    <string name="ext_media_badremoval_notification_title" product="default" msgid="6872152882604407837">"Kartu SD tiba-tiba dicabut"</string>
    <string name="ext_media_badremoval_notification_message" product="nosdcard" msgid="4329848819865594241">"Lepas penyimpanan USB sebelum menghapus untuk menghindari kehilangan data."</string>
    <string name="ext_media_badremoval_notification_message" product="default" msgid="7260183293747448241">"Lepaskan kartu SD sebelum mencabutnya untuk mencegah hilangnya data."</string>
    <string name="ext_media_safe_unmount_notification_title" product="nosdcard" msgid="3967973893270360230">"Penyimpanan USB aman untuk dilepas"</string>
    <string name="ext_media_safe_unmount_notification_title" product="default" msgid="6729801130790616200">"Kartu SD aman dicabut"</string>
    <string name="ext_media_safe_unmount_notification_message" product="nosdcard" msgid="6142195361606493530">"Anda dapat melepas penyimpanan USB dengan aman."</string>
    <string name="ext_media_safe_unmount_notification_message" product="default" msgid="568841278138377604">"Anda dapat melepaskan kartu SD dengan aman."</string>
    <string name="ext_media_nomedia_notification_title" product="nosdcard" msgid="4486377230140227651">"Penyimpanan USB dihapus"</string>
    <string name="ext_media_nomedia_notification_title" product="default" msgid="8902518030404381318">"Cabut kartu SD"</string>
    <string name="ext_media_nomedia_notification_message" product="nosdcard" msgid="6921126162580574143">"Penyimpanan USB dihapus. Masukkan media baru."</string>
    <string name="ext_media_nomedia_notification_message" product="default" msgid="3870120652983659641">"Kartu SD dicabut. Masukkan yang baru."</string>
    <string name="activity_list_empty" msgid="1675388330786841066">"Tidak ditemukan aktivitas yang sesuai."</string>
    <string name="permlab_pkgUsageStats" msgid="8787352074326748892">"perbarui statistik penggunaan komponen"</string>
    <string name="permdesc_pkgUsageStats" msgid="1106612424254277630">"Mengizinkan apl memodifikasi statistik penggunaan komponen yang dikumpulkan. Tidak untuk digunakan oleh apl normal."</string>
    <string name="permlab_copyProtectedData" msgid="4341036311211406692">"menyalin konten"</string>
    <string name="permdesc_copyProtectedData" msgid="4390697124288317831">"Mengizinkan apl menjalankan layanan kontainer default untuk menyalin konten. Tidak untuk digunakan oleh apl normal."</string>
    <string name="permlab_route_media_output" msgid="1642024455750414694">"Menentukan rute keluaran media"</string>
    <string name="permdesc_route_media_output" msgid="4932818749547244346">"Memungkinkan aplikasi menentukan rute keluaran media ke perangkat eksternal lainnya."</string>
    <string name="tutorial_double_tap_to_zoom_message_short" msgid="4070433208160063538">"Sentuh dua kali untuk mengontrol perbesar/perkecil"</string>
    <string name="gadget_host_error_inflating" msgid="4882004314906466162">"Tidak dapat menambahkan widget."</string>
    <string name="ime_action_go" msgid="8320845651737369027">"Buka"</string>
    <string name="ime_action_search" msgid="658110271822807811">"Telusuri"</string>
    <string name="ime_action_send" msgid="2316166556349314424">"Kirimkan"</string>
    <string name="ime_action_next" msgid="3138843904009813834">"Berikutnya"</string>
    <string name="ime_action_done" msgid="8971516117910934605">"Selesai"</string>
    <string name="ime_action_previous" msgid="1443550039250105948">"Sebelumnya"</string>
    <string name="ime_action_default" msgid="2840921885558045721">"Lakukan"</string>
    <string name="dial_number_using" msgid="5789176425167573586">"Panggil nomor "\n"menggunakan<xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="create_contact_using" msgid="4947405226788104538">"Buat kontak "\n"menggunakan <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="grant_credentials_permission_message_header" msgid="2106103817937859662">"Satu atau beberapa apl meminta izin untuk mengakses akun Anda, sekarang dan di masa mendatang."</string>
    <string name="grant_credentials_permission_message_footer" msgid="3125211343379376561">"Apakah Anda ingin mengizinkan permintaan ini?"</string>
    <string name="grant_permissions_header_text" msgid="6874497408201826708">"Permintaan akses"</string>
    <string name="allow" msgid="7225948811296386551">"Izinkan"</string>
    <string name="deny" msgid="2081879885755434506">"Tolak"</string>
    <string name="permission_request_notification_title" msgid="6486759795926237907">"Izin dimintakan"</string>
    <string name="permission_request_notification_with_subtitle" msgid="8530393139639560189">"Izin dimintakan"\n"untuk akun <xliff:g id="ACCOUNT">%s</xliff:g>."</string>
    <string name="input_method_binding_label" msgid="1283557179944992649">"Metode masukan"</string>
    <string name="sync_binding_label" msgid="3687969138375092423">"Sinkron"</string>
    <string name="accessibility_binding_label" msgid="4148120742096474641">"Aksesibilitas"</string>
    <string name="wallpaper_binding_label" msgid="1240087844304687662">"Wallpaper"</string>
    <string name="chooser_wallpaper" msgid="7873476199295190279">"Ubah wallpaper"</string>
    <string name="vpn_title" msgid="19615213552042827">"VPN diaktifkan"</string>
    <string name="vpn_title_long" msgid="6400714798049252294">"VPN diaktifkan oleh <xliff:g id="APP">%s</xliff:g>"</string>
    <string name="vpn_text" msgid="3011306607126450322">"Sentuh untuk mengelola jaringan."</string>
    <string name="vpn_text_long" msgid="6407351006249174473">"Tersambung ke <xliff:g id="SESSION">%s</xliff:g>. Sentuh untuk mengelola jaringan."</string>
    <string name="upload_file" msgid="2897957172366730416">"Pilih file"</string>
    <string name="no_file_chosen" msgid="6363648562170759465">"Tidak ada file yang dipilih"</string>
    <string name="reset" msgid="2448168080964209908">"Setel ulang"</string>
    <string name="submit" msgid="1602335572089911941">"Kirim"</string>
    <string name="car_mode_disable_notification_title" msgid="3164768212003864316">"Mode mobil diaktifkan"</string>
    <string name="car_mode_disable_notification_message" msgid="8035230537563503262">"Sentuh untuk keluar dari mode mobil."</string>
    <string name="tethered_notification_title" msgid="3146694234398202601">"Tethering (Penambatan) atau hotspot aktif"</string>
    <string name="tethered_notification_message" msgid="6857031760103062982">"Sentuh untuk menyiapkan."</string>
    <string name="back_button_label" msgid="2300470004503343439">"Kembali"</string>
    <string name="next_button_label" msgid="1080555104677992408">"Selanjutnya"</string>
    <string name="skip_button_label" msgid="1275362299471631819">"Lewati"</string>
    <string name="throttle_warning_notification_title" msgid="4890894267454867276">"penggunaan data seluler yang tinggi"</string>
    <string name="throttle_warning_notification_message" msgid="3340822228599337743">"Sentuh untuk mempelajari lebih lanjut tentang penggunaan data seluler."</string>
    <string name="throttled_notification_title" msgid="6269541897729781332">"Batas data seluler terlampaui"</string>
    <string name="throttled_notification_message" msgid="5443457321354907181">"Sentuh untuk mempelajari lebih lanjut tentang penggunaan data seluler."</string>
    <string name="no_matches" msgid="8129421908915840737">"Tidak ada kecocokan"</string>
    <string name="find_on_page" msgid="1946799233822820384">"Temukan pada laman"</string>
  <plurals name="matches_found">
    <item quantity="one" msgid="8167147081136579439">"1 kecocokan"</item>
    <item quantity="other" msgid="4641872797067609177">"<xliff:g id="INDEX">%d</xliff:g> dari <xliff:g id="TOTAL">%d</xliff:g>"</item>
  </plurals>
    <string name="action_mode_done" msgid="7217581640461922289">"Selesai"</string>
    <string name="progress_unmounting" product="nosdcard" msgid="3923810448507612746">"Melepas penyimpanan USB..."</string>
    <string name="progress_unmounting" product="default" msgid="1327894998409537190">"Melepas kartu SD..."</string>
    <string name="progress_erasing" product="nosdcard" msgid="4521573321524340058">"Menghapus penyimpanan USB..."</string>
    <string name="progress_erasing" product="default" msgid="6596988875507043042">"Menghapus kartu SD..."</string>
    <string name="format_error" product="nosdcard" msgid="6299769563624776948">"Tidak dapat menghapus penyimpanan USB."</string>
    <string name="format_error" product="default" msgid="7315248696644510935">"Tidak dapat menghapus kartu SD."</string>
    <string name="media_bad_removal" msgid="7960864061016603281">"Kartu SD dihapus sebelum dilepas."</string>
    <string name="media_checking" product="nosdcard" msgid="418188720009569693">"Saat ini penyimpanan USB sedang diperiksa."</string>
    <string name="media_checking" product="default" msgid="7334762503904827481">"Kartu SD sedang diperiksa."</string>
    <string name="media_removed" msgid="7001526905057952097">"Kartu SD telah dihapus."</string>
    <string name="media_shared" product="nosdcard" msgid="5830814349250834225">"Saat ini penyimpanan USB sedang digunakan oleh komputer."</string>
    <string name="media_shared" product="default" msgid="5706130568133540435">"Kartu SD sedang digunakan oleh komputer."</string>
    <string name="media_unknown_state" msgid="729192782197290385">"Media eksternal dalam status tidak diketahui."</string>
    <string name="share" msgid="1778686618230011964">"Bagikan"</string>
    <string name="find" msgid="4808270900322985960">"Temukan"</string>
    <string name="websearch" msgid="4337157977400211589">"Penelusuran Web"</string>
    <string name="gpsNotifTicker" msgid="5622683912616496172">"Permintaan lokasi dari <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="gpsNotifTitle" msgid="5446858717157416839">"Permintaan lokasi"</string>
    <string name="gpsNotifMessage" msgid="1374718023224000702">"Diminta oleh <xliff:g id="NAME">%1$s</xliff:g> (<xliff:g id="SERVICE">%2$s</xliff:g>)"</string>
    <string name="gpsVerifYes" msgid="2346566072867213563">"Ya"</string>
    <string name="gpsVerifNo" msgid="1146564937346454865">"Tidak"</string>
    <string name="sync_too_many_deletes" msgid="5296321850662746890">"Penghapusan melebihi batas"</string>
    <string name="sync_too_many_deletes_desc" msgid="496551671008694245">"Terdapat <xliff:g id="NUMBER_OF_DELETED_ITEMS">%1$d</xliff:g> item yang dihapus untuk <xliff:g id="TYPE_OF_SYNC">%2$s</xliff:g>, akun <xliff:g id="ACCOUNT_NAME">%3$s</xliff:g>. Apa yang ingin Anda lakukan?"</string>
    <string name="sync_really_delete" msgid="2572600103122596243">"Hapus item"</string>
    <string name="sync_undo_deletes" msgid="2941317360600338602">"Urungkan penghapusan"</string>
    <string name="sync_do_nothing" msgid="3743764740430821845">"Jangan lakukan apa pun untuk saat ini"</string>
    <string name="choose_account_label" msgid="5655203089746423927">"Pilih akun"</string>
    <string name="add_account_label" msgid="2935267344849993553">"Tambahkan akun"</string>
    <string name="add_account_button_label" msgid="3611982894853435874">"Tambahkan akun"</string>
    <string name="number_picker_increment_button" msgid="2412072272832284313">"Tambah"</string>
    <string name="number_picker_decrement_button" msgid="476050778386779067">"Kurangi"</string>
    <string name="number_picker_increment_scroll_mode" msgid="3073101067441638428">"<xliff:g id="VALUE">%s</xliff:g> sentuh dan tahan."</string>
    <string name="number_picker_increment_scroll_action" msgid="9101473045891835490">"Geser ke atas untuk menambah dan ke bawah untuk mengurangi."</string>
    <string name="time_picker_increment_minute_button" msgid="8865885114028614321">"Tambah menit"</string>
    <string name="time_picker_decrement_minute_button" msgid="6246834937080684791">"Kurangi menit"</string>
    <string name="time_picker_increment_hour_button" msgid="3652056055810223139">"Tambah jam"</string>
    <string name="time_picker_decrement_hour_button" msgid="1377479863429214792">"Kurangi jam"</string>
    <string name="time_picker_increment_set_pm_button" msgid="4147590696151230863">"Menyetel PM"</string>
    <string name="time_picker_decrement_set_am_button" msgid="8302140353539486752">"Setel AM"</string>
    <string name="date_picker_increment_month_button" msgid="5369998479067934110">"Tambah bulan"</string>
    <string name="date_picker_decrement_month_button" msgid="1832698995541726019">"Kurangi bulan"</string>
    <string name="date_picker_increment_day_button" msgid="7130465412308173903">"Tambah hari"</string>
    <string name="date_picker_decrement_day_button" msgid="4131881521818750031">"Kurangi hari"</string>
    <string name="date_picker_increment_year_button" msgid="6318697384310808899">"Tambah tahun"</string>
    <string name="date_picker_decrement_year_button" msgid="4482021813491121717">"Kurangi tahun"</string>
    <string name="keyboardview_keycode_alt" msgid="4856868820040051939">"Alt"</string>
    <string name="keyboardview_keycode_cancel" msgid="1203984017245783244">"Batal"</string>
    <string name="keyboardview_keycode_delete" msgid="3337914833206635744">"Hapus"</string>
    <string name="keyboardview_keycode_done" msgid="1992571118466679775">"Selesai"</string>
    <string name="keyboardview_keycode_mode_change" msgid="4547387741906537519">"Pengubahan mode"</string>
    <string name="keyboardview_keycode_shift" msgid="2270748814315147690">"Shift"</string>
    <string name="keyboardview_keycode_enter" msgid="2985864015076059467">"Enter"</string>
    <string name="activitychooserview_choose_application" msgid="2125168057199941199">"Pilih apl"</string>
    <string name="shareactionprovider_share_with" msgid="806688056141131819">"Berbagi dengan"</string>
    <string name="shareactionprovider_share_with_application" msgid="5627411384638389738">"Berbagi dengan <xliff:g id="APPLICATION_NAME">%s</xliff:g>"</string>
    <string name="content_description_sliding_handle" msgid="415975056159262248">"Gagang geser. Sentuh &amp; tahan."</string>
    <string name="description_direction_up" msgid="7169032478259485180">"Geser ke atas untuk <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_direction_down" msgid="5087739728639014595">"Geser ke bawah untuk <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_direction_left" msgid="7207478719805562165">"Geser ke kiri untuk <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_direction_right" msgid="8034433242579600980">"Geser ke kanan untuk <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_target_unlock" msgid="2228524900439801453">"Membuka gembok"</string>
    <string name="description_target_camera" msgid="969071997552486814">"Kamera"</string>
    <string name="description_target_silent" msgid="893551287746522182">"Senyap"</string>
    <string name="description_target_soundon" msgid="30052466675500172">"Suara hidup"</string>
    <string name="description_target_search" msgid="3091587249776033139">"Telusuri"</string>
    <string name="description_target_unlock_tablet" msgid="3833195335629795055">"Gesek untuk membuka kunci."</string>
    <string name="keyboard_headset_required_to_hear_password" msgid="7011927352267668657">"Pasang headset untuk mendengar tombol sandi yang diucapkan."</string>
    <string name="keyboard_password_character_no_headset" msgid="2859873770886153678">"Titik."</string>
    <string name="action_bar_home_description" msgid="5293600496601490216">"Navigasi ke beranda"</string>
    <string name="action_bar_up_description" msgid="2237496562952152589">"Navigasi naik"</string>
    <string name="action_menu_overflow_description" msgid="2295659037509008453">"Opsi lainnya"</string>
    <string name="storage_internal" msgid="4891916833657929263">"Penyimpanan internal"</string>
    <string name="storage_sd_card" msgid="3282948861378286745">"Kartu SD"</string>
    <string name="storage_usb" msgid="3017954059538517278">"Penyimpanan USB"</string>
    <string name="extract_edit_menu_button" msgid="8940478730496610137">"Edit"</string>
    <string name="data_usage_warning_title" msgid="1955638862122232342">"Peringatan penggunaan data"</string>
    <string name="data_usage_warning_body" msgid="2814673551471969954">"Sentuh utk mlht pnggnaan &amp; stln."</string>
    <string name="data_usage_3g_limit_title" msgid="7093334419518706686">"Data 2G-3G dinonaktifkan"</string>
    <string name="data_usage_4g_limit_title" msgid="7636489436819470761">"Data 4G dinonaktifkan"</string>
    <string name="data_usage_mobile_limit_title" msgid="7869402519391631884">"Data seluler dinonaktifkan"</string>
    <string name="data_usage_wifi_limit_title" msgid="8992154736441284865">"Data Wi-Fi dinonaktifkan"</string>
    <string name="data_usage_limit_body" msgid="3317964706973601386">"Sentuh untuk mengaktifkan."</string>
    <string name="data_usage_3g_limit_snoozed_title" msgid="7026739121138005231">"Batas data 2G-3G terlampaui"</string>
    <string name="data_usage_4g_limit_snoozed_title" msgid="1106562779311209039">"Batas data 4G terlampaui"</string>
    <string name="data_usage_mobile_limit_snoozed_title" msgid="279240572165412168">"Batas data seluler terlampaui"</string>
    <string name="data_usage_wifi_limit_snoozed_title" msgid="8743856006384825974">"Batas data Wi-Fi terlampaui"</string>
    <string name="data_usage_limit_snoozed_body" msgid="7035490278298441767">"<xliff:g id="SIZE">%s</xliff:g> melebihi batas yang ditentukan."</string>
    <string name="data_usage_restricted_title" msgid="5965157361036321914">"Data latar belakang dibatasi"</string>
    <string name="data_usage_restricted_body" msgid="6741521330997452990">"Sentuh utk mnghapus pembatasan."</string>
    <string name="ssl_certificate" msgid="6510040486049237639">"Sertifikat keamanan"</string>
    <string name="ssl_certificate_is_valid" msgid="6825263250774569373">"Sertifikat ini valid."</string>
    <string name="issued_to" msgid="454239480274921032">"Diterbitkan ke:"</string>
    <string name="common_name" msgid="2233209299434172646">"Nama umum:"</string>
    <string name="org_name" msgid="6973561190762085236">"Organisasi:"</string>
    <string name="org_unit" msgid="7265981890422070383">"Unit organisasi:"</string>
    <string name="issued_by" msgid="2647584988057481566">"Diterbitkan oleh:"</string>
    <string name="validity_period" msgid="8818886137545983110">"Validitas:"</string>
    <string name="issued_on" msgid="5895017404361397232">"Diterbitkan pada:"</string>
    <string name="expires_on" msgid="3676242949915959821">"Kedaluwarsa pada:"</string>
    <string name="serial_number" msgid="758814067660862493">"Nomor seri:"</string>
    <string name="fingerprints" msgid="4516019619850763049">"Sidik jari:"</string>
    <string name="sha256_fingerprint" msgid="4391271286477279263">"Sidik jari SHA-256:"</string>
    <string name="sha1_fingerprint" msgid="7930330235269404581">"Sidik jari SHA-1:"</string>
    <string name="activity_chooser_view_see_all" msgid="4292569383976636200">"Lihat semua"</string>
    <string name="activity_chooser_view_dialog_title_default" msgid="4710013864974040615">"Pilih kegiatan"</string>
    <string name="share_action_provider_share_with" msgid="5247684435979149216">"Berbagi dengan"</string>
    <string name="status_bar_device_locked" msgid="3092703448690669768">"Perangkat tergembok."</string>
    <string name="list_delimeter" msgid="3975117572185494152">", "</string>
    <string name="sending" msgid="3245653681008218030">"Mengirim..."</string>
    <string name="launchBrowserDefault" msgid="2057951947297614725">"Luncurkan Browser?"</string>
    <string name="SetupCallDefault" msgid="5834948469253758575">"Terima panggilan?"</string>
    <string name="activity_resolver_use_always" msgid="8017770747801494933">"Selalu"</string>
    <string name="activity_resolver_use_once" msgid="2404644797149173758">"Hanya sekali"</string>
    <string name="default_audio_route_name" product="tablet" msgid="4617053898167127471">"Tablet"</string>
    <string name="default_audio_route_name" product="default" msgid="4239291273420140123">"Ponsel"</string>
    <string name="default_audio_route_name_headphones" msgid="8119971843803439110">"Headphone"</string>
    <string name="default_audio_route_name_dock_speakers" msgid="6240602982276591864">"Pengeras suara dok"</string>
    <string name="default_audio_route_name_hdmi" msgid="7986404173839007682">"Audio HDMI"</string>
    <string name="default_audio_route_category_name" msgid="3722811174003886946">"Sistem"</string>
    <string name="bluetooth_a2dp_audio_route_name" msgid="8575624030406771015">"Audio Bluetooth"</string>
    <string name="media_route_chooser_grouping_done" msgid="7966438307723317169">"Selesai"</string>
</resources>
