<?xml version="1.0" encoding="utf-8"?>
<resources>
	<string name="role_admin">Administrator</string>
	<string name="role_editor">Editor</string>
	<string name="role_author">Penulis</string>
	<string name="role_contributor">Kontributor</string>
	<string name="role_follower">Pengikut</string>
	<string name="role_viewer">Penonton</string>
	<string name="error_post_my_profile_no_connection">Tak ada koneksi, gagal menyimpan profil Anda</string>
	<string name="alignment_none">Tak ada</string>
	<string name="alignment_left">Kiri</string>
	<string name="alignment_right">Kanan</string>
	<string name="site_settings_list_editor_action_mode_title">Memilih %1$d</string>
	<string name="error_fetch_users_list">Gagal menampilkan pengguna situs</string>
	<string name="plans_manage">Kelola paket Anda di \nWordPress.com/plans</string>
	<string name="people_empty_list_filtered_viewers">Anda belum memiliki satupun pengunjung.</string>
	<string name="title_follower">Pengikut</string>
	<string name="title_email_follower">Pengikut Email</string>
	<string name="people_fetching">Mengambil pengguna...</string>
	<string name="people_empty_list_filtered_email_followers">Anda belum memiliki satupun pengikut email.</string>
	<string name="people_empty_list_filtered_followers">Anda belum memiliki satupun pengikut.</string>
	<string name="people_empty_list_filtered_users">Anda belum memiliki satupun pengguna.</string>
	<string name="people_dropdown_item_email_followers">Pengikut Email</string>
	<string name="people_dropdown_item_viewers">Pengunjung</string>
	<string name="people_dropdown_item_followers">Pengikut</string>
	<string name="people_dropdown_item_team">Tim</string>
	<string name="invite_message_usernames_limit">Undang hingga 10 alamat email dan/atau nama pengguna WordPress.com. Mereka yang membutuhkan nama pengguna akan menerima instruksi untuk mendapatkannya.</string>
	<string name="viewer_remove_confirmation_message">Jika Anda menghapus pengunjung ini, ia tak akan bisa mengunjungi situs ini lagi.\n\nApakah Anda masih ingin menghapus pengunjung ini?</string>
	<string name="follower_remove_confirmation_message">Jika dihapus, pengunjung ini akan berhenti menerima notifikasi mengenai situs ini, kecuali mereka mengikuti lagi.\n\nApakah Anda masih ingin menghapus pengunjung ini?</string>
	<string name="follower_subscribed_since">Sejak %1$s</string>
	<string name="reader_label_view_gallery">Lihat Galeri</string>
	<string name="error_remove_follower">Gagal menghapus pengikut</string>
	<string name="error_remove_viewer">Gagal menghapus pengunjung</string>
	<string name="error_fetch_email_followers_list">Gagal menampilkan pengikut email situs</string>
	<string name="error_fetch_followers_list">Gagal menampilkan pengikut situs</string>
	<string name="editor_failed_uploads_switch_html">Beberapa media gagal diunggah. Anda bisa pindah ke mode HTML\n        dalam situasi begini. Hapus semua unggahan yang gagal dan lanjutkan?</string>
	<string name="format_bar_description_html">Mode HTML</string>
	<string name="visual_editor">Editor Visual</string>
	<string name="image_thumbnail">Miniatur gambar</string>
	<string name="format_bar_description_ul">Daftar tak bernomor</string>
	<string name="format_bar_description_ol">Daftar bernomor</string>
	<string name="format_bar_description_more">Sisipkan lagi</string>
	<string name="format_bar_description_media">Sisipkan media</string>
	<string name="format_bar_description_strike">Coretan</string>
	<string name="format_bar_description_quote">Blok kutipan</string>
	<string name="format_bar_description_link">Sisipkan tautan</string>
	<string name="format_bar_description_underline">Garis bawah</string>
	<string name="format_bar_description_italic">Miring</string>
	<string name="image_settings_save_toast">Perubahan tersimpan</string>
	<string name="image_caption">Keterangan gambar</string>
	<string name="image_alt_text">Alt text</string>
	<string name="image_link_to">Tautkan ke</string>
	<string name="image_width">Lebar</string>
	<string name="format_bar_description_bold">Tebal</string>
	<string name="image_settings_dismiss_dialog_title">Buang perubahan yang belum disimpan?</string>
	<string name="stop_upload_dialog_title">Stop mengunggah?</string>
	<string name="stop_upload_button">Stop Pengunggahan</string>
	<string name="alert_error_adding_media">Terjadi galat saat menyisipkan media</string>
	<string name="alert_action_while_uploading">Anda sedang mengunggah media. Mohon tunggu hingga selesai.</string>
	<string name="alert_insert_image_html_mode">Gagal menyisipkan media dalam mode HTML. Silakan pindah ke mode visual.</string>
	<string name="uploading_gallery_placeholder">Mengunggah galeri...</string>
	<string name="invite_sent">Undangan berhasil terkirim</string>
	<string name="tap_to_try_again">Ketuk untuk mencoba lagi!</string>
	<string name="invite_error_some_failed">Undangan terkirim namun terjadi galat!</string>
	<string name="invite_error_for_username">%1$s: %2$s</string>
	<string name="invite_error_sending">Terjadi sebuah galat saat mencoba mengirimkan undangan!</string>
	<string name="invite_error_invalid_usernames_multiple">Gagal mengirim: Ada nama pengguna atau email yang tak valid</string>
	<string name="invite_error_invalid_usernames_one">Gagal mengirim: Ada sebuah nama pengguna atau email yang tak valid</string>
	<string name="invite_error_no_usernames">Mohon tambahkan sedikitnya satu nama pengguna</string>
	<string name="invite_message_info">(Opsional) Anda bisa memasukkan sebuah pesan sepanjang 500 karakter yang akan disertakan dalam undangan bagi para pengguna.</string>
	<string name="invite_message_remaining_other">%d karakter tersisa</string>
	<string name="invite_message_remaining_one">1 karakter tersisa</string>
	<string name="invite_message_remaining_zero">0 karakter tersisa</string>
	<string name="invite_invalid_email">Alamat email \'%s\' invalid</string>
	<string name="invite_message_title">Pesan Kustom</string>
	<string name="invite_already_a_member">Sudah ada anggota dengan nama pengguna \'%s\'</string>
	<string name="invite_username_not_found">Tak ditemukan pengguna dengan nama \'%s\'</string>
	<string name="invite">Undang</string>
	<string name="invite_names_title">Nama pengguna atau Email</string>
	<string name="signup_succeed_signin_failed">Akun Anda telah dibuat namun terjadi galat saat mencoba masuk.\n        Coba untuk masuk dengan nama pengguna dan password baru Anda.</string>
	<string name="send_link">Kirim tautan</string>
	<string name="my_site_header_external">Eksternal</string>
	<string name="invite_people">Undang Orang-orang</string>
	<string name="label_clear_search_history">Bersihkan riwayat pencarian</string>
	<string name="dlg_confirm_clear_search_history">Bersihkan riwayat pencarian?</string>
	<string name="reader_empty_posts_in_search_description">Tak ditemukan pos untuk %s dalam bahasa Anda</string>
	<string name="reader_label_post_search_running">Mencari...</string>
	<string name="reader_label_related_posts">Bacaan Terkait</string>
	<string name="reader_empty_posts_in_search_title">Tak ditemukan pos</string>
	<string name="reader_label_post_search_explainer">Cari seluruh blog publik WordPress.com</string>
	<string name="reader_hint_post_search">Cari WordPress.com</string>
	<string name="reader_title_related_post_detail">Pos Terkait</string>
	<string name="reader_title_search_results">Cari %s</string>
	<string name="preview_screen_links_disabled">Tautan dinonaktifkan pada laman pratinjau</string>
	<string name="draft_explainer">Pos ini adalah sebuah draf yang belum diterbitkan</string>
	<string name="send">Kirim</string>
	<string name="user_remove_confirmation_message">Jika Anda menghapus %1$s, pengguna tsb tak bisa mengakses situs ini lagi, tetapi semua konten yang telah dibuat oleh %1$s akan tetap ada di situs ini.\n\nApakah Anda masih ingin menghapus pengguna ini?</string>
	<string name="person_removed">Berhasil menghapus %1$s</string>
	<string name="person_remove_confirmation_title">Hapus %1$s</string>
	<string name="reader_empty_posts_in_custom_list">Situs dalam daftar ini belum memposting apa pun baru-baru ini</string>
	<string name="people">Orang</string>
	<string name="edit_user">Edit Pengguna</string>
	<string name="role">Peran</string>
	<string name="error_remove_user">Tidak dapat menghapus pengguna</string>
	<string name="error_update_role">Tidak dapat memperbarui peran pengguna</string>
	<string name="error_fetch_viewers_list">Gagal menampilkan pengunjung situs</string>
	<string name="gravatar_camera_and_media_permission_required">Izin diperlukan untuk memilih atau mengambil foto</string>
	<string name="error_updating_gravatar">Terjadi galat saat memperbarui Gravatar</string>
	<string name="error_locating_image">Terjadi galat saat mencari gambar yang dipangkas</string>
	<string name="error_refreshing_gravatar">Terjadi galat saat memuat ulang Gravatar</string>
	<string name="gravatar_tip">Baru! Ketuk Gravatar untuk mengubahnya!</string>
	<string name="error_cropping_image">Terjadi galat saat memangkas gambar</string>
	<string name="launch_your_email_app">Luncurkan aplikasi surat elektronik</string>
	<string name="checking_email">Memeriksa surat elektronik</string>
	<string name="not_on_wordpress_com">Tidak di WordPress.com?</string>
	<string name="magic_link_unavailable_error_message">Saat ini tidak tersedia. Masukkan kata sandi Anda</string>
	<string name="check_your_email">Periksa surat elektronik Anda</string>
	<string name="get_a_link_sent_to_your_email_to_sign_in_instantly">Dapatkan tautan yang dikirimkan ke surat elektronik Anda untuk langsung masuk</string>
	<string name="logging_in">Proses masuk</string>
	<string name="enter_your_password_instead">Sebaiknya masukkan kata sandi Anda</string>
	<string name="web_address_dialog_hint">Ditampilkan secara publik saat Anda berkomentar.</string>
	<string name="jetpack_not_connected_message">Plugin Jetpack terpasang, tetapi tidak terhubung ke WordPress.com. Ingin menghubungkan Jetpack?</string>
	<string name="username_email">Surat elektronik atau nama pengguna</string>
	<string name="jetpack_not_connected">Plugin Jetpack tidak terhubung</string>
	<string name="new_editor_reflection_error">Visual editor tidak kompatibel dengan perangkat Anda. Ini\n dinonaktifkan secara otomatis.</string>
	<string name="stats_insights_latest_post_no_title">(tanpa judul)</string>
	<string name="capture_or_pick_photo">Ambil atau pilih foto</string>
	<string name="plans_post_purchase_text_themes">Anda sekarang memiliki akses tak terbatas ke tema Premium. Pratinjau tema apa pun di situs Anda untuk memulai.</string>
	<string name="plans_post_purchase_button_themes">Telusuri Tema</string>
	<string name="plans_post_purchase_title_themes">Temukan tema Premium yang sempurna</string>
	<string name="plans_post_purchase_button_video">Mulai pos baru</string>
	<string name="plans_post_purchase_text_video">Anda dapat mengunggah dan meng-hosting video di situs Anda dengan VideoPress dan penyimpanan media yang diperluas.</string>
	<string name="plans_post_purchase_title_video">Hidupkan pos dengan video</string>
	<string name="plans_post_purchase_button_customize">Sesuaikan Situs saya</string>
	<string name="plans_post_purchase_text_customize">Anda sekarang memiliki akses ke fon khusus, warna khusus, dan kemampuan pengeditan CSS khusus.</string>
	<string name="plans_post_purchase_text_intro">Situs Anda melakukan perubahan dalam keseruan! Sekarang jelajahi fitur baru Anda dan pilih dari mana Anda ingin memulainya.</string>
	<string name="plans_post_purchase_title_customize">Menyesuaikan Fon &amp; Warna</string>
	<string name="plans_post_purchase_title_intro">Semua milik Anda, saatnya melangkah!</string>
	<string name="export_your_content_message">Pos, halaman, dan pengaturan Anda akan dikirimkan melalui email kepada Anda pada %s.</string>
	<string name="plan">Paket</string>
	<string name="plans">Paket</string>
	<string name="plans_loading_error">Tidak dapat memuat paket</string>
	<string name="export_your_content">Ekspor konten Anda</string>
	<string name="exporting_content_progress">Mengekspor konten…</string>
	<string name="export_email_sent">Email ekspor sudah dikirimkan!</string>
	<string name="premium_upgrades_message">Anda memiliki peningkatan premium aktif dalam situs Anda. Batalkan peningkatan sebelum menghapus situs Anda.</string>
	<string name="show_purchases">Tampilkan pembelian</string>
	<string name="checking_purchases">Memeriksa pembelian</string>
	<string name="premium_upgrades_title">Peningkatan Premium</string>
	<string name="purchases_request_error">Terjadi masalah. Tidak dapat meminta pembelian.</string>
	<string name="delete_site_progress">Menghapus situs…</string>
	<string name="delete_site_summary">Tindakan ini tidak dapat dibatalkan. Menghapus situs Anda akan membuang semua konten, kontributor, dan domain dari situs.</string>
	<string name="delete_site_hint">Hapus situs</string>
	<string name="export_site_hint">Ekspor situs Anda ke file XML</string>
	<string name="are_you_sure">Apakah Anda Yakin?</string>
	<string name="export_site_summary">Jika Anda yakin, segera luangkan waktu dan ekspor konten Anda sekarang. Itu tidak dapat dikembalikan di masa mendatang.</string>
	<string name="keep_your_content">Jaga Konten Anda</string>
	<string name="domain_removal_hint">Domain yang tidak berfungsi setelah Anda menghapus situs Anda</string>
	<string name="domain_removal_summary">Hati-hati! Menghapus situs Anda juga akan menghapus domain Anda di bawah ini.</string>
	<string name="primary_domain">Domain Primer</string>
	<string name="domain_removal">Penghapusan Domain</string>
	<string name="error_deleting_site_summary">Ada kesalahan saat menghapus situs Anda. Hubungi dukungan untuk bantuan selengkapnya</string>
	<string name="error_deleting_site">Kesalahan saat menghapus situs</string>
	<string name="confirm_delete_site_prompt">Harap ketikkan %1$s di bidang di bawah untuk mengonfirmasi. Situs Anda akan dihapus selamanya.</string>
	<string name="site_settings_export_content_title">Ekspor konten</string>
	<string name="contact_support">Hubungi dukungan</string>
	<string name="confirm_delete_site">Konfirmasi Penghapusan Situs</string>
	<string name="start_over_text">Jika Anda menginginkan sebuah situs tetapi tidak menginginkan beberapa pos dan halaman yang Anda miliki saat ini, tim dukungan kami dapat menghapus pos, halaman, media, dan komentar untuk Anda.\n\nTindakan ini akan membuat situs dan URL Anda tetap aktif, tetapi memberi Anda titik awal yang segar di pembuatan konten. Cukup hubungi kami untuk membersihkan konten Anda saat ini.</string>
	<string name="site_settings_start_over_hint">Mulai dari awal situs Anda</string>
	<string name="let_us_help">Mari Kami Bantu</string>
	<string name="me_btn_app_settings">Pengaturan Aplikasi</string>
	<string name="start_over">Mulai</string>
	<string name="editor_remove_failed_uploads">Buang unggahan yang gagal</string>
	<string name="editor_toast_failed_uploads">Gagal mengunggah beberapa media. Tidak dapat menyimpan atau menerbitkan\n pos Anda dalam status ini. Anda ingin membuang semua media yang gagal?</string>
	<string name="comments_empty_list_filtered_trashed">Tidak ada komentar Sampah</string>
	<string name="site_settings_advanced_header">Lanjutan</string>
	<string name="comments_empty_list_filtered_pending">Tidak ada komentar Tertunda</string>
	<string name="comments_empty_list_filtered_approved">Tidak ada komentar Disetujui</string>
	<string name="button_done">Selesai</string>
	<string name="button_skip">Lewati</string>
	<string name="site_timeout_error">Tidak dapat terhubung ke situs WordPress karena kesalahan Waktu Habis.</string>
	<string name="xmlrpc_malformed_response_error">Tidak dapat terhubung. Pemasangan WordPress merespons dengan dokumen XML-RPC yang tidak valid.</string>
	<string name="xmlrpc_missing_method_error">Tidak dapat terhubung. Metode XML-RPC yang diperlukan tidak ditemukan di server.</string>
	<string name="post_format_status">Status</string>
	<string name="post_format_video">Video</string>
	<string name="alignment_center">Tengah</string>
	<string name="theme_free">Gratis</string>
	<string name="theme_all">Semua</string>
	<string name="theme_premium">Premium</string>
	<string name="post_format_chat">Obrolan</string>
	<string name="post_format_gallery">Galeri</string>
	<string name="post_format_image">Gambar</string>
	<string name="post_format_link">Tautan</string>
	<string name="post_format_quote">Kutipan</string>
	<string name="post_format_standard">Standar</string>
	<string name="notif_events">Informasi tentang kursus dan acara WordPress.com (online &amp; tatap muka).</string>
	<string name="post_format_aside">Ke samping</string>
	<string name="post_format_audio">Audio</string>
	<string name="notif_surveys">Kesempatan untuk berpartisipasi dalam riset &amp; survei WordPress.com.</string>
	<string name="notif_tips">Kiat untuk mendapat maksimal dari WordPress.com.</string>
	<string name="notif_community">Komunitas</string>
	<string name="replies_to_my_comments">Balas komentar saya</string>
	<string name="notif_suggestions">Saran</string>
	<string name="notif_research">Riset</string>
	<string name="site_achievements">Prestasi situs</string>
	<string name="username_mentions">Penyebutan nama pengguna</string>
	<string name="likes_on_my_posts">Suka pada pos saya</string>
	<string name="site_follows">Pengikut Situs</string>
	<string name="likes_on_my_comments">Suka pada komentar saya</string>
	<string name="comments_on_my_site">Komentar di situs saya</string>
	<string name="site_settings_list_editor_summary_other">%d items</string>
	<string name="site_settings_list_editor_summary_one">1 item</string>
	<string name="approve_auto_if_previously_approved">Komentar pengguna yang diketahui</string>
	<string name="approve_auto">Semua pengguna</string>
	<string name="approve_manual">Tak ada komentar</string>
	<string name="site_settings_paging_summary_other">%d komentar per halaman</string>
	<string name="site_settings_paging_summary_one">1 komentar per halaman</string>
	<string name="site_settings_multiple_links_summary_other">Minta persetujuan untuk lebih dari %d tautan</string>
	<string name="site_settings_multiple_links_summary_one">Minta persetujuan untuk lebih dari 1 tautan</string>
	<string name="site_settings_multiple_links_summary_zero">Minta persetujuan untuk lebih dari 0 tautan</string>
	<string name="detail_approve_auto">Otomatis setujui komentar semua orang.</string>
	<string name="detail_approve_auto_if_previously_approved">Otomatis setujui jika pengguna memiliki komentar yang disetujui sebelumnya</string>
	<string name="detail_approve_manual">Wajibkan persetujuan manual untuk komentar semua orang.</string>
	<string name="filter_trashed_posts">Dibuang</string>
	<string name="days_quantity_one">1 hari</string>
	<string name="days_quantity_other">%d hari</string>
	<string name="filter_published_posts">Diterbitkan</string>
	<string name="filter_draft_posts">Draf</string>
	<string name="filter_scheduled_posts">Terjadwal</string>
	<string name="pending_email_change_snackbar">Klik tautan verifikasi di email yang dikirimkan ke %1$s untuk mengonfirmasi alamat baru Anda</string>
	<string name="primary_site">Situs Utama</string>
	<string name="web_address">Alamat Web</string>
	<string name="editor_toast_uploading_please_wait">Saat ini Anda sedang mengunggah media. Harap tunggu hingga selesai.</string>
	<string name="error_refresh_comments_showing_older">Komentar tidak dapat disegarkan pada saat ini - menunjukkan komentar lama</string>
	<string name="editor_post_settings_set_featured_image">Atur Gambar Unggulan</string>
	<string name="editor_post_settings_featured_image">Gambar Unggulan</string>
	<string name="new_editor_promo_desc">Aplikasi WordPress untuk Android sekarang berisi visual baru yang cantik\n penyunting Cobalah dengan membuat pos baru.</string>
	<string name="new_editor_promo_title">Penyunting baru</string>
	<string name="new_editor_promo_button_label">Bagus, terima kasih!</string>
	<string name="visual_editor_enabled">Editor Visual diaktifkan</string>
	<string name="editor_content_placeholder">Editor Visual diaktifkan</string>
	<string name="editor_page_title_placeholder">Judul Halaman</string>
	<string name="editor_post_title_placeholder">Judul Kiriman</string>
	<string name="email_address">Alamat email</string>
	<string name="preference_show_visual_editor">Tampilkan editor visual</string>
	<string name="dlg_sure_to_delete_comments">Hapus komentar ini secara permanen?</string>
	<string name="preference_editor">Penyunting</string>
	<string name="dlg_sure_to_delete_comment">Hapus komentar ini secara permanen?</string>
	<string name="mnu_comment_delete_permanently">Hapus</string>
	<string name="comment_deleted_permanently">Komentar dihapus</string>
	<string name="mnu_comment_untrash">Pulihkan</string>
	<string name="comments_empty_list_filtered_spam">Tidak ada komentar Spam</string>
	<string name="could_not_load_page">Tidak dapat memuat halaman</string>
	<string name="comment_status_all">Semua</string>
	<string name="interface_language">Bahasa Antarmuka</string>
	<string name="off">Nonaktif</string>
	<string name="about_the_app">Tentang aplikasi</string>
	<string name="error_post_account_settings">Tidak dapat menyimpan pengaturan akun Anda</string>
	<string name="error_post_my_profile">Tidak dapat menyimpan profil Anda</string>
	<string name="error_fetch_account_settings">Tidak dapat mengambil pengaturan akun Anda</string>
	<string name="error_fetch_my_profile">Tidak dapat mengambil profil Anda</string>
	<string name="stats_widget_promo_ok_btn_label">Baik, mengerti</string>
	<string name="stats_widget_promo_desc">Tambahkan widget ke layar awal Anda untuk mengakses Statistik Anda dalam sekali klik.</string>
	<string name="stats_widget_promo_title">Widget Statistik Layar Awal</string>
	<string name="site_settings_unknown_language_code_error">Kode bahasa tidak dikenali</string>
	<string name="site_settings_threading_dialog_description">Izinkan komentar ditumpuk dalam utas.</string>
	<string name="site_settings_threading_dialog_header">Utas hingga</string>
	<string name="remove">Buang</string>
	<string name="search">Cari</string>
	<string name="add_category">Tambahkan kategori</string>
	<string name="disabled">Dinonaktifkan</string>
	<string name="site_settings_image_original_size">Ukuran Asli</string>
	<string name="privacy_private">Situs Anda hanya dapat dilihat oleh Anda dan pengguna yang Anda setujui</string>
	<string name="privacy_public_not_indexed">Situs Anda dapat dilihat oleh semua orang, tetapi meminta mesin pencari untuk tidak mengindeks.</string>
	<string name="privacy_public">Situs Anda dapat dilihat oleh semua orang dan mungkin diindeks berdasarkan mesin pencarian.</string>
	<string name="about_me_hint">Beberapa kata tentang Anda...</string>
	<string name="about_me">Tentang saya</string>
	<string name="public_display_name_hint">Nama tampilan secara default akan menjadi nama pengguna Anda bila tidak diatur</string>
	<string name="public_display_name">Nama tampilan publik</string>
	<string name="my_profile">Profil Saya</string>
	<string name="first_name">Nama depan</string>
	<string name="last_name">Nama belakang</string>
	<string name="site_privacy_public_desc">Izinkan mesin pencari untuk mengindeks situs ini</string>
	<string name="site_privacy_hidden_desc">Larang mesin pencari untuk mengindeks situs ini</string>
	<string name="site_privacy_private_desc">Saya ingin situs saya menjadi privat, hanya terlihat oleh pengguna yang saya pilih</string>
	<string name="cd_related_post_preview_image">Gambar pratinjau pos terkait</string>
	<string name="error_post_remote_site_settings">Tidak dapat menyimpan info situs</string>
	<string name="error_fetch_remote_site_settings">Tidak dapat mengambil info situs</string>
	<string name="error_media_upload_connection">Terjadi kesalahan koneksi saat mengunggah media</string>
	<string name="site_settings_disconnected_toast">Terputus, penyuntingan dinonaktifkan.</string>
	<string name="site_settings_unsupported_version_error">Versi WordPress tidak didukung</string>
	<string name="site_settings_multiple_links_dialog_description">Minta persetujuan untuk komentar yang memiliki lebih dari jumlah tautan ini.</string>
	<string name="site_settings_close_after_dialog_switch_text">Tutup secara otomatis</string>
	<string name="site_settings_close_after_dialog_description">Tutup komentar secara otomatis di artikel.</string>
	<string name="site_settings_paging_dialog_description">Bagi utas komentar ke dalam beberapa halaman.</string>
	<string name="site_settings_paging_dialog_header">Komentar per halaman</string>
	<string name="site_settings_close_after_dialog_title">Tutup komentar</string>
	<string name="site_settings_blacklist_description">Saat komentar memuat kata-kata berikut dalam isi, nama, tautan, email, atau IP, maka akan ditandai sebagai spam. Anda bisa menuliskan bagian kata, jadi "press" akan cocok dengan "WordPress."</string>
	<string name="site_settings_hold_for_moderation_description">Saat komentar memuat kata-kata berikut dalam isi, nama, tautan, email, atau IP, maka akan tertunda dalam antrean moderasi. Anda bisa menuliskan bagian kata, jadi "press" akan cocok dengan "WordPress."</string>
	<string name="site_settings_list_editor_input_hint">Masukkan kata atau kalimat</string>
	<string name="site_settings_list_editor_no_items_text">Tidak ada item</string>
	<string name="site_settings_learn_more_caption">Anda dapat mengubah pengaturan ini untuk pos individual.</string>
	<string name="site_settings_rp_preview3_site">dalam "Upgrade"</string>
	<string name="site_settings_rp_preview3_title">Fokus Upgrade: VideoPress For Weddings</string>
	<string name="site_settings_rp_preview2_site">dalam "Applikasi"</string>
	<string name="site_settings_rp_preview2_title">Applikasi WordPress untuk Android Melakukan Perubahan Besar</string>
	<string name="site_settings_rp_preview1_site">dalam "Mobile"</string>
	<string name="site_settings_rp_preview1_title">Pembaruan Besar untuk iPhone/iPad Kini Tersedia</string>
	<string name="site_settings_rp_show_images_title">Tampilkan Gambar</string>
	<string name="site_settings_rp_show_header_title">Tampilkan Header</string>
	<string name="site_settings_rp_switch_summary">Pos terkait menampilkan konten yang relevan dari situs Anda di bawah pos Anda.</string>
	<string name="site_settings_rp_switch_title">Tampilkan Pos Terkait</string>
	<string name="site_settings_delete_site_hint">Hapus data situs Anda dari aplikasi</string>
	<string name="site_settings_blacklist_hint">Komentar yang cocok dengan filter ditandai sebagai spam</string>
	<string name="site_settings_moderation_hold_hint">Komentar yang cocok dengan filter akan menunggu antrean moderasi</string>
	<string name="site_settings_multiple_links_hint">Abaikan batasan tautan untuk pengguna yang dikenal</string>
	<string name="site_settings_whitelist_hint">Penulis komentar harus mempunyai komentar yang sudah disetujui sebelumnya</string>
	<string name="site_settings_user_account_required_hint">Pengguna harus sudah terdaftar dan masuk untuk memberi komentar</string>
	<string name="site_settings_identity_required_hint">Penulis komentar harus memasukkan nama dan email</string>
	<string name="site_settings_manual_approval_hint">Komentar harus disetujui secara manual</string>
	<string name="site_settings_paging_hint">Tampilkan komentar dalam beberapa bagian dengan ukuran spesifik</string>
	<string name="site_settings_threading_hint">Izinkan komentar cabang sampai kedalaman tertentu</string>
	<string name="site_settings_sort_by_hint">Tentukan urutan komentar yang ditampilkan</string>
	<string name="site_settings_close_after_hint">Larang komentar setelah waktu yang ditentukan</string>
	<string name="site_settings_receive_pingbacks_hint">Perbolehkan pemberitahuan tautan dari blog lain</string>
	<string name="site_settings_send_pingbacks_hint">Upayakan memberi notifikasi ke blog lain yang tertaut dari artikel</string>
	<string name="site_settings_allow_comments_hint">Perbolehkan pembaca untuk menulis komentar</string>
	<string name="site_settings_discussion_hint">Tampilkan dan ubah pengaturan diskusi situs</string>
	<string name="site_settings_more_hint">Tampilkan semua pengaturan Diskusi yang ada</string>
	<string name="site_settings_related_posts_hint">Tampilkan atau sembunyikan pos terkait di pembaca</string>
	<string name="site_settings_upload_and_link_image_hint">Perbolehkan untuk selalu mengirim gambar dalam ukuran asli</string>
	<string name="site_settings_image_width_hint">Ubah ukuran gambar dalam pos ke lebar berikut</string>
	<string name="site_settings_format_hint">Tentukan format pos baru</string>
	<string name="site_settings_category_hint">Tentukan kategori pos baru</string>
	<string name="site_settings_location_hint">Tambahkan secara otomatis data lokasi ke pos Anda</string>
	<string name="site_settings_password_hint">Ubah kata sandi Anda</string>
	<string name="site_settings_username_hint">Akun pengguna saat ini</string>
	<string name="site_settings_language_hint">Bahasa yang dipakai dalam blog mayoritas adalah</string>
	<string name="site_settings_privacy_hint">Kontrol siapa saja yang dapat melihat situs Anda</string>
	<string name="site_settings_address_hint">Mengubah alamat Anda saat ini tidak dimungkinkan</string>
	<string name="site_settings_tagline_hint">Deskripsi pendek atau kalimat unik untuk menggambarkan blog Anda</string>
	<string name="site_settings_title_hint">Dalam beberapa kata, jelaskan mengenai situs ini</string>
	<string name="site_settings_whitelist_known_summary">Komentar dari user yang dikenal</string>
	<string name="site_settings_whitelist_all_summary">Komentar dari semua pengguna</string>
	<string name="site_settings_threading_summary">%d level</string>
	<string name="site_settings_privacy_private_summary">Privat</string>
	<string name="site_settings_privacy_hidden_summary">Tersembunyi</string>
	<string name="site_settings_delete_site_title">Hapus Situs</string>
	<string name="site_settings_privacy_public_summary">Publik</string>
	<string name="site_settings_blacklist_title">Daftar hitam</string>
	<string name="site_settings_moderation_hold_title">Menunggu untuk Moderasi</string>
	<string name="site_settings_multiple_links_title">Tautan dalam komentar</string>
	<string name="site_settings_whitelist_title">Otomatis disetujui</string>
	<string name="site_settings_threading_title">Rangkaian</string>
	<string name="site_settings_paging_title">Penomoran halaman</string>
	<string name="site_settings_sort_by_title">Urut berdasar</string>
	<string name="site_settings_account_required_title">Pengguna harus sudah masuk</string>
	<string name="site_settings_identity_required_title">Harus menyertakan nama dan email</string>
	<string name="site_settings_receive_pingbacks_title">Terima Ping Balik</string>
	<string name="site_settings_send_pingbacks_title">Kirim Ping Balik</string>
	<string name="site_settings_allow_comments_title">Izinkan Komentar</string>
	<string name="site_settings_default_format_title">Format Baku</string>
	<string name="site_settings_default_category_title">Kategori Baku</string>
	<string name="site_settings_location_title">Aktifkan Lokasi</string>
	<string name="site_settings_address_title">Alamat</string>
	<string name="site_settings_title_title">Judul Situs</string>
	<string name="site_settings_tagline_title">Slogan</string>
	<string name="site_settings_this_device_header">Perangkat ini</string>
	<string name="site_settings_discussion_new_posts_header">Baku untuk pos baru</string>
	<string name="site_settings_account_header">Akun</string>
	<string name="site_settings_writing_header">Tulisan</string>
	<string name="site_settings_general_header">Umum</string>
	<string name="newest_first">Terbaru terlebih dahulu</string>
	<string name="discussion">Diskusi</string>
	<string name="privacy">Privasi</string>
	<string name="related_posts">Pos Terkait</string>
	<string name="comments">Komentar</string>
	<string name="close_after">Tutup setelah</string>
	<string name="oldest_first">Paling lama terlebih dahulu</string>
	<string name="media_error_no_permission_upload">Anda tidak memiliki izin untuk menambahkan media ke dalam situs</string>
	<string name="never">Tidak pernah</string>
	<string name="unknown">Tidak diketahui</string>
	<string name="reader_err_get_post_not_found">Pos ini tidak ada lagi</string>
	<string name="reader_err_get_post_not_authorized">Anda tidak diizinkan melihat pos ini</string>
	<string name="reader_err_get_post_generic">Gagal mengambil pos ini</string>
	<string name="blog_name_no_spaced_allowed">Alamat situs tak boleh memuat spasi</string>
	<string name="invalid_username_no_spaces">Nama pengguna tak boleh memuat spasi</string>
	<string name="reader_empty_followed_blogs_no_recent_posts_description">Situs-situs yang Anda ikuti belum menerbitkan pos apapun belakangan ini</string>
	<string name="reader_empty_followed_blogs_no_recent_posts_title">Tak ada pos terbaru</string>
	<string name="media_details_copy_url_toast">URL tersalin dalam papan klip</string>
	<string name="edit_media">Edit media</string>
	<string name="media_details_copy_url">Salin URL</string>
	<string name="media_details_label_date_uploaded">Terunggah</string>
	<string name="media_details_label_date_added">Ditambahkan</string>
	<string name="selected_theme">Tema Terpilih</string>
	<string name="could_not_load_theme">Tidak dapat memuat tema</string>
	<string name="theme_activation_error">Terjadi masalah. Tidak dapat mengaktifkan tema</string>
	<string name="theme_by_author_prompt_append"> oleh %1$s</string>
	<string name="theme_prompt">Terima kasih sudah memilih %1$s</string>
	<string name="theme_try_and_customize">Coba &amp; Sesuaikan</string>
	<string name="theme_view">Lihat</string>
	<string name="theme_details">Rincian</string>
	<string name="theme_support">Dukungan</string>
	<string name="theme_done">SELESAI</string>
	<string name="theme_manage_site">KELOLA SITUS</string>
	<string name="title_activity_theme_support">Tema</string>
	<string name="theme_activate">Aktifkan</string>
	<string name="date_range_start_date">Tanggal Mulai</string>
	<string name="date_range_end_date">Tanggal Selesai</string>
	<string name="current_theme">Tema Saat Ini</string>
	<string name="customize">Sesuaikan</string>
	<string name="details">Rincian</string>
	<string name="support">Dukungan</string>
	<string name="active">Aktif</string>
	<string name="stats_referrers_spam_generic_error">Ada masalah selama pengoperasian. Status spam tidak diubah.</string>
	<string name="stats_referrers_marking_not_spam">Menandai sebagai bukan spam</string>
	<string name="stats_referrers_unspam">Bukan spam</string>
	<string name="stats_referrers_marking_spam">Menandai sebagai spam</string>
	<string name="theme_auth_error_authenticate">Gagal mengambil tema: gagal mengautentikasi pengguna</string>
	<string name="post_published">Pos diterbitkan</string>
	<string name="page_published">Halaman diterbitkan</string>
	<string name="post_updated">Pos diperbarui</string>
	<string name="page_updated">Halaman diperbarui</string>
	<string name="stats_referrers_spam">Spam</string>
	<string name="theme_no_search_result_found">Maaf, tema tidak ditemukan.</string>
	<string name="media_file_name">Nama file: %s</string>
	<string name="media_uploaded_on">Diunggah pada: %s</string>
	<string name="media_dimensions">Dimensi: %s</string>
	<string name="upload_queued">Diantrekan</string>
	<string name="media_file_type">Jenis file: %s</string>
	<string name="reader_label_gap_marker">Muat pos lainnya</string>
	<string name="notifications_no_search_results">Tidak ada situs yang cocok dengan \'%s\'</string>
	<string name="search_sites">Cari situs</string>
	<string name="notifications_empty_view_reader">Lihat Pembaca</string>
	<string name="unread">Belum dibaca</string>
	<string name="notifications_empty_action_followers_likes">Dapatkan perhatian: komentari pos yang sudah Anda baca.</string>
	<string name="notifications_empty_action_comments">Bergabung dengan percakapan: komentari pos dari blog yang Anda ikuti.</string>
	<string name="notifications_empty_action_unread">Aktifkan kembali percakapan: tulis pos baru.</string>
	<string name="notifications_empty_action_all">Aktiflah! Komentari pos dari blog yang Anda ikuti.</string>
	<string name="notifications_empty_likes">Belum ada suka baru untuk ditampilkan.</string>
	<string name="notifications_empty_followers">Tidak ada pengikut untuk dilaporkan…sampai sekarang.</string>
	<string name="notifications_empty_comments">Tidak ada komentar baru…lagi.</string>
	<string name="notifications_empty_unread">Anda semua terperangkap!</string>
	<string name="stats_widget_error_jetpack_no_blogid">Harap akses Statistik di aplikasi, dan coba tambahkan widget nantinya</string>
	<string name="stats_widget_error_readd_widget">Hapus widget dan tambahkan lagi</string>
	<string name="stats_widget_error_no_visible_blog">Statistik tidak dapat diakses tanpa blog terlihat</string>
	<string name="stats_widget_error_no_permissions">Akun WordPress.com Anda tidak dapat mengakses Statistik di blog ini</string>
	<string name="stats_widget_error_no_account">Harap masuk ke WordPress</string>
	<string name="stats_widget_error_generic">Statistik tidak dapat dimuat</string>
	<string name="stats_widget_loading_data">Memuat data…</string>
	<string name="stats_widget_name_for_blog">Statistik Hari Ini untuk %1$s</string>
	<string name="stats_widget_name">Statistik Hari Ini WordPress</string>
	<string name="add_location_permission_required">Izin diperlukan untuk menambahkan lokasi</string>
	<string name="add_media_permission_required">Izin diperlukan untuk menambahkan media</string>
	<string name="access_media_permission_required">Izin diperlukan untuk mengakses media</string>
	<string name="stats_enable_rest_api_in_jetpack">Untuk menampilkan statistik Anda, aktifkan module JSON API di Jetpack.</string>
	<string name="error_open_list_from_notification">Pos atau laman ini diterbitkan di situs lain</string>
	<string name="reader_short_comment_count_multi">%s Komentar</string>
	<string name="reader_short_comment_count_one">1 Komentar</string>
	<string name="reader_label_submit_comment">KIRIM</string>
	<string name="reader_hint_comment_on_post">Tanggapan untuk pos...</string>
	<string name="reader_discover_visit_blog">Kunjungi %s</string>
	<string name="reader_discover_attribution_blog">Semula diposkan pada %s</string>
	<string name="reader_discover_attribution_author">Semula diposkan oleh %s</string>
	<string name="reader_discover_attribution_author_and_blog">Semula diposkan oleh %1$s pada %2$s</string>
	<string name="reader_short_like_count_multi">%s Suka</string>
	<string name="reader_short_like_count_one">1 Suka</string>
	<string name="reader_label_follow_count">%,d pengikut</string>
	<string name="reader_short_like_count_none">Suka</string>
	<string name="reader_menu_tags">Sunting tag dan blog</string>
	<string name="reader_title_post_detail">Pos Pembaca</string>
	<string name="local_draft_explainer">Pos ini adalah konsep lokal yang belum pernah diterbitkan</string>
	<string name="local_changes_explainer">Pos ini memiliki perubahan lokal yang belum pernah diterbitkan</string>
	<string name="notifications_push_summary">Pengaturan pemberitahuan yang muncul di perangkat Anda.</string>
	<string name="notifications_email_summary">Pengaturan pemberitahuan yang dikirim melalui email yang terhubung dengan akun Anda.</string>
	<string name="notifications_tab_summary">Pengaturan pemberitahuan yang muncul di tab Pemberitahuan.</string>
	<string name="notifications_disabled">Pemberitahuan aplikasi telah dinonaktifkan. Ketuk di sini untuk mengaktifkannya di Pengaturan.</string>
	<string name="notification_types">Jenis Pemberitahuan</string>
	<string name="error_loading_notifications">Tidak dapat memuat pengaturan pemberitahuan</string>
	<string name="replies_to_your_comments">Membalas komentar Anda</string>
	<string name="comment_likes">Menyukai komentar</string>
	<string name="app_notifications">Pemberitahuan aplikasi</string>
	<string name="notifications_tab">Tab pemberitahuan</string>
	<string name="email">Email</string>
	<string name="notifications_comments_other_blogs">Komentar di situs lain</string>
	<string name="notifications_other">Lainnya</string>
	<string name="notifications_wpcom_updates">Berita Terbaru WordPress.com</string>
	<string name="notifications_account_emails">Email dari WordPress.com</string>
	<string name="notifications_account_emails_summary">Kami akan selalu mengirim email penting terkait akun Anda, namun Anda juga dapat memperoleh beberapa tambahan yang bermanfaat.</string>
	<string name="notifications_sights_and_sounds">Penglihatan dan Suara</string>
	<string name="your_sites">Situs Anda</string>
	<string name="stats_insights_latest_post_trend">Telah %1$s sejak %2$s diterbitkan. Berikut ini gambaran kinerja pos sejauh ini…</string>
	<string name="stats_insights_latest_post_summary">Ringkasan Pos Terbaru</string>
	<string name="button_revert">Kembalikan</string>
	<string name="days_ago">%d hari yang lalu</string>
	<string name="yesterday">Kemarin</string>
	<string name="connectionbar_no_connection">Tak ada koneksi</string>
	<string name="page_trashed">Halaman dibuang ke tong sampah</string>
	<string name="stats_no_activity_this_period">Tidak ada aktivitas dalam periode ini</string>
	<string name="trashed">Dibuang</string>
	<string name="button_back">Kembali</string>
	<string name="page_deleted">Halaman dihapus</string>
	<string name="button_stats">Statistik</string>
	<string name="button_trash">Buang</string>
	<string name="button_preview">Pratinjau</string>
	<string name="button_view">Lihat</string>
	<string name="button_edit">Sunting</string>
	<string name="button_publish">Terbitkan</string>
	<string name="post_deleted">Pos dihapus</string>
	<string name="post_trashed">Pos dibuang ke tong sampah</string>
	<string name="my_site_no_sites_view_subtitle">Mau menambahkan satu?</string>
	<string name="my_site_no_sites_view_title">Anda belum punya situs WordPress sama sekali.</string>
	<string name="my_site_no_sites_view_drake">Ilustrasi</string>
	<string name="reader_toast_err_follow_blog_not_authorized">Anda tidak punya otoritas untuk mengakses blog ini.</string>
	<string name="reader_toast_err_follow_blog_not_found">Blog ini tak bisa ditemukan</string>
	<string name="undo">Urungkan</string>
	<string name="tabbar_accessibility_label_my_site">Situs Saya</string>
	<string name="tabbar_accessibility_label_me">Saya</string>
	<string name="editor_toast_changes_saved">Perubahan disimpan</string>
	<string name="passcodelock_prompt_message">Masukkan PIN</string>
	<string name="push_auth_expired">Permintaan sudah kedaluwarsa. Masuk ke WordPress.com untuk mencoba lagi.</string>
	<string name="ignore">Abaikan</string>
	<string name="stats_insights_most_popular_percent_views">%1$d%% dilihat</string>
	<string name="stats_insights_best_ever">Tampilan Terbaik</string>
	<string name="stats_insights_most_popular_hour">Jam paling populer</string>
	<string name="stats_insights_most_popular_day">Hari paling populer</string>
	<string name="stats_insights_popular">Hari dan jam paling populer</string>
	<string name="stats_insights_today">Statistik Hari Ini</string>
	<string name="stats_insights_all_time">Pos, tampilan, dan pengunjung sepanjang waktu</string>
	<string name="stats_insights">Wawasan</string>
	<string name="stats_sign_in_jetpack_different_com_account">Untuk melihat statistik Anda, masuk ke akun WordPress.com yang Anda gunakan untuk terhubung dengan Jetpack.</string>
	<string name="stats_other_recent_stats_moved_label">Mencari Statistik Terbaru Lainnya? Kami telah memindahkannya ke halaman Wawasan.</string>
	<string name="me_disconnect_from_wordpress_com">Putuskan koneksi WordPress.com</string>
	<string name="me_btn_login_logout">Log masuk/keluar</string>
	<string name="me_connect_to_wordpress_com">Koneksikan ke WordPress.com</string>
	<string name="site_picker_cant_hide_current_site">"%s" tidak tersembunyi karena itu adalah situs saat ini</string>
	<string name="me_btn_support">Bantuan &amp; Dukungan</string>
	<string name="account_settings">Pengaturan Akun</string>
	<string name="site_picker_create_dotcom">Buat situs WordPress.com</string>
	<string name="site_picker_add_self_hosted">Tambahkan situs mandiri (self-hosted)</string>
	<string name="site_picker_edit_visibility">Tampilkan/sembunyikan situs</string>
	<string name="site_picker_add_site">Tambahkan situs</string>
	<string name="site_picker_title">Pilih situs</string>
	<string name="my_site_btn_switch_site">Ganti Situs</string>
	<string name="my_site_btn_view_admin">Tampilkan Admin</string>
	<string name="my_site_btn_view_site">Tampilkan Situs</string>
	<string name="my_site_header_look_and_feel">Tampilan dan Nuansa</string>
	<string name="my_site_header_publish">Terbitkan</string>
	<string name="my_site_btn_site_settings">Pengaturan</string>
	<string name="my_site_btn_blog_posts">Pos Blog</string>
	<string name="reader_label_new_posts_subtitle">Ketuk untuk menampilkannya</string>
	<string name="my_site_header_configuration">Konfigurasi</string>
	<string name="notifications_account_required">Masuk ke WordPress.com untuk notifikasi</string>
	<string name="stats_unknown_author">Penulis Tak Dikenal</string>
	<string name="image_added">Gambar ditambahkan</string>
	<string name="signout">Putuskan koneksi</string>
	<string name="sign_out_wpcom_confirm">Memutuskan koneksi akun Anda akan menghapus seluruh data WordPress.com untuk @%s dari perangkat ini, termasuk draf lokal dan perubahan lokal.</string>
	<string name="select_all">Pilih semua</string>
	<string name="deselect_all">Batalkan semua pilihan</string>
	<string name="show">Tampilkan</string>
	<string name="hide">Sembunyikan</string>
	<string name="select_from_new_picker">Beberapa-pilihan dengan pemilih baru</string>
	<string name="loading_blog_images">Memuat gambar</string>
	<string name="loading_blog_videos">Memuat video</string>
	<string name="no_media_sources">Gagal memuat media</string>
	<string name="error_loading_videos">Galat memuat video</string>
	<string name="stats_generic_error">Statistik yang diminta gagal dimuat</string>
	<string name="error_loading_blog_images">Gagal memuat gambar</string>
	<string name="error_loading_blog_videos">Gagal memuat video</string>
	<string name="error_loading_images">Galat memuat gambar</string>
	<string name="no_device_videos">Tak ada video</string>
	<string name="no_blog_images">Tak ada gambar</string>
	<string name="no_blog_videos">Tak ada video</string>
	<string name="no_device_images">Tak ada gambar</string>
	<string name="loading_videos">Memuat video</string>
	<string name="loading_images">Memuat gambar</string>
	<string name="no_media">Tak ada media</string>
	<string name="auth_required">Masuk lagi untuk melanjutkan.</string>
	<string name="sign_in_jetpack">Masuk ke akun WordPress.com Anda untuk menyambungkan dengan Jetpack.</string>
	<string name="two_step_sms_sent">Periksa pesan teks Anda untuk melihat kode verifikasi.</string>
	<string name="two_step_footer_button">Kirimkan kode via pesan teks</string>
	<string name="verify">Verifikasikan</string>
	<string name="two_step_footer_label">Masukkan kode dari authenticator app.</string>
	<string name="invalid_verification_code">Kode verifikasi tidak valid</string>
	<string name="verification_code">Kode verifikasi</string>
	<string name="editor_toast_invalid_path">Lokasi file tidak valid</string>
	<string name="error_publish_no_network">Tak bisa menerbitkan tanpa koneksi internet. Tersimpan sebagai draf.</string>
	<string name="tab_title_device_videos">Video Perangkat</string>
	<string name="tab_title_device_images">Gambar Perangkat</string>
	<string name="tab_title_site_images">Gambar Situs</string>
	<string name="tab_title_site_videos">Video Situs</string>
	<string name="take_video">Ambil video</string>
	<string name="take_photo">Ambil foto</string>
	<string name="media_picker_title">Pilih media</string>
	<string name="add_to_post">Tambahkan ke Pos</string>
	<string name="language">Bahasa</string>
	<string name="device">Perangkat</string>
	<string name="media_details_label_file_name">Nama file</string>
	<string name="media_details_label_file_type">Tipe file</string>
	<string name="posts_fetching">Memuat pos...</string>
	<string name="media_fetching">Memuat media...</string>
	<string name="toast_err_post_uploading">Gagal membuka pos saat diunggah</string>
	<string name="comments_fetching">Memuat komentar...</string>
	<string name="pages_fetching">Memuat laman...</string>
	<string name="stats_view_search_terms">Terma-terma Pencarian</string>
	<string name="stats_view_authors">Para Penulis</string>
	<string name="stats_entry_search_terms">Terma Pencarian</string>
	<string name="stats_empty_search_terms_desc">Pelajari lebih lanjut mengenai trafik pencarian Anda dengan melihat terma-terma pencarian yang dipergunakan oleh pengunjung saat menemukan situs Anda.</string>
	<string name="stats_empty_search_terms">Tak ada terma pencarian yang tercatat</string>
	<string name="stats_search_terms_unknown_search_terms">Terma Pencarian Tak Dikenal</string>
	<string name="stats_followers_total_wpcom_paged">Menampilkan %1$d - %2$d dari %3$s Pengikut WordPress.com</string>
	<string name="stats_followers_total_email_paged">Menampilkan %1$d - %2$d dari %3$s Pengikut via Email</string>
	<string name="reader_empty_posts_request_failed">Gagal memuat pos-pos</string>
	<string name="publisher">Penerbit:</string>
	<string name="error_notification_open">Gagal membuka notifikasi</string>
	<string name="post_uploading">Mengunggah</string>
	<string name="stats_overall">Keseluruhan</string>
	<string name="reader_empty_posts_in_blog">Blog ini kosong</string>
	<string name="stats_recent_weeks">Beberapa Minggu Terakhir</string>
	<string name="stats_total">Total</string>
	<string name="reader_label_new_posts">Pos baru</string>
	<string name="error_copy_to_clipboard">Terjadi kesalahan saat menyalin teks ke clipboard</string>
	<string name="stats_period">Periode</string>
	<string name="logs_copied_to_clipboard">Log aplikasi sudah disalin ke clipboard</string>
	<string name="stats_average_per_day">Rata-Rata per Hari</string>
	<string name="stats_months_and_years">Bulan dan Tahun</string>
	<string name="reader_page_recommended_blogs">Situs yang mungkin Anda sukai</string>
	<string name="stats_comments_total_comments_followers">Total pos dengan pengikut komentar: %1$s</string>
	<string name="stats_view_publicize">Publikasikan</string>
	<string name="stats_view_followers">Pengikut</string>
	<string name="stats_view_countries">Negara</string>
	<string name="stats_likes">Suka</string>
	<string name="stats_view_top_posts_and_pages">Pos &amp; Halaman</string>
	<string name="stats_view_videos">Video</string>
	<string name="stats_entry_followers">Pengikut</string>
	<string name="stats_totals_publicize">Pengikut</string>
	<string name="stats_empty_geoviews_desc">Telusuri daftar untuk melihat negara dan wilayah mana yang menghasilkan lalu-lintas terbanyak ke situs Anda.</string>
	<string name="stats_empty_geoviews">Tak ada negara yang direkam</string>
	<string name="stats_empty_top_posts_desc">Temukan konten Anda yang paling sering dilihat, dan periksa kinerja pos dan halaman individual.</string>
	<string name="stats_empty_referrers_title">Tidak ada perujuk yang direkam</string>
	<string name="stats_empty_top_posts_title">Tidak ada pos atau halaman yang dilihat</string>
	<string name="stats_empty_clicks_title">Tidak ada klik yang terekam</string>
	<string name="stats_empty_referrers_desc">Pelajari selengkapnya tentang visibilitas situs Anda dengan memeriksa situs web dan mesin pencari yang mengirim paling banyak lalu lintas ke situs Anda</string>
	<string name="stats_empty_tags_and_categories">Tidak ada pos atau halaman ditandai yang dilihat</string>
	<string name="stats_empty_clicks_desc">Jika konten Anda menyertakan tautan ke situs lainnya, Anda akan melihat tautan mana yang paling sering diklik pengunjung Anda.</string>
	<string name="stats_empty_top_authors_desc">Lacak tayangan di pos setiap kontributor, dan lihat lebih dekat untuk menemukan konten paling populer dari setiap penulis.</string>
	<string name="stats_empty_tags_and_categories_desc">Dapatkan ikhtisar topik paling populer di situs Anda, seperti yang tampak di pos teratas Anda dari minggu lalu.</string>
	<string name="stats_empty_video">Tidak ada video yang diputar</string>
	<string name="stats_empty_video_desc">Jika Anda sudah mengunggah video menggunakan VideoPress, cari tahu berapa kali video tersebut sudah ditonton.</string>
	<string name="stats_empty_comments_desc">Jika Anda mengizinkan komentar di situs Anda, lacak komentator teratas Anda dan temukan konten apa yang memicu percakapan paling ramai, berdasarkan 1000 komentar terbaru.</string>
	<string name="stats_empty_followers">Tak ada pengikut</string>
	<string name="stats_empty_publicize_desc">Tetap pantau pengikut Anda dari berbagai layanan jejaring sosial menggunakan publikasikan.</string>
	<string name="stats_empty_publicize">Tidak ada pengikut publikasikan yang terekam</string>
	<string name="stats_comments_by_posts_and_pages">Berdasarkan Pos &amp; Halaman</string>
	<string name="stats_empty_followers_desc">Tetap lacak seluruh pengikut Anda, dan berapa lama masing-masing pengikut Anda telah mengikuti situs Anda.</string>
	<string name="stats_view">Lihat</string>
	<string name="stats_followers_seconds_ago">detik yang lalu</string>
	<string name="stats_followers_total_email">Total Pengikut Email: %1$s</string>
	<string name="stats_other_recent_stats_label">Statistik Terbaru Lainnya</string>
	<string name="stats_view_all">Lihat semua</string>
	<string name="stats_for">Statistik untuk %s</string>
	<string name="themes_fetching">Mengambil tema…</string>
	<string name="stats_visitors">Pengunjung</string>
	<string name="stats_timeframe_years">Tahun</string>
	<string name="stats_views">Tampilan</string>
	<string name="stats_pagination_label">Halaman %1$s dari %2$s</string>
	<string name="stats_entry_clicks_link">Tautan</string>
	<string name="stats_entry_top_commenter">Penulis</string>
	<string name="stats_entry_publicize">Layanan</string>
	<string name="stats_entry_video_plays">Video</string>
	<string name="stats_totals_followers">Sejak</string>
	<string name="stats_comments_by_authors">Berdasarkan Penulis</string>
	<string name="stats_followers_email_selector">Email</string>
	<string name="stats_followers_total_wpcom">Total Pengikut WordPress.com: %1$s</string>
	<string name="stats_followers_wpcom_selector">WordPress.com</string>
	<string name="stats_followers_days">%1$d hari</string>
	<string name="stats_followers_a_minute_ago">satu menit yang lalu</string>
	<string name="stats_followers_hours">%1$d jam</string>
	<string name="stats_followers_a_day">Satu hari</string>
	<string name="stats_followers_minutes">%1$d menit</string>
	<string name="stats_followers_an_hour_ago">satu jam yang lalu</string>
	<string name="stats_followers_years">%1$d tahun</string>
	<string name="stats_followers_a_month">Satu bulan</string>
	<string name="stats_followers_a_year">Satu tahun</string>
	<string name="stats_followers_months">%1$d bulan</string>
	<string name="ssl_certificate_details">Rincian</string>
	<string name="sure_to_remove_account">Hapus situs ini?</string>
	<string name="delete_sure_post">Hapus pos ini</string>
	<string name="delete_sure">Hapus draf ini</string>
	<string name="delete_sure_page">Hapus laman ini</string>
	<string name="confirm_delete_media">Hapus item terpilih?</string>
	<string name="confirm_delete_multi_media">Hapus semua item terpilih?</string>
	<string name="cab_selected">%d terpilih</string>
	<string name="media_gallery_date_range">Menampilkan media dari %1$s hingga %2$s</string>
	<string name="reader_empty_posts_liked">Anda belum menyukai pos sama sekali</string>
	<string name="faq_button">Tanya Jawab Umum</string>
	<string name="browse_our_faq_button">Telusuri Tanya Jawab Umum kami</string>
	<string name="nux_help_description">Kunjungi pusat bantuan untuk mendapatkan jawaban atas pertanyaan umum, atau kunjungi forum untuk mengajukan pertanyaan baru</string>
	<string name="agree_terms_of_service">Dengan membuat akun, berarti Anda menyetujui untuk mematuhi %1$sKetentuan Layanan%2$s</string>
	<string name="create_new_blog_wpcom">Buat blog WordPress.com</string>
	<string name="new_blog_wpcom_created">Blog WordPress.com sudah dibuat!</string>
	<string name="reader_empty_comments">Belum ada komentar</string>
	<string name="reader_empty_posts_in_tag">Belum ada pos dengan tag ini</string>
	<string name="reader_label_comment_count_multi">%,d komentar</string>
	<string name="reader_label_view_original">Lihat artikel asli</string>
	<string name="reader_label_like">Suka</string>
	<string name="reader_label_liked_by">Disukai oleh</string>
	<string name="reader_label_comment_count_single">Satu komentar</string>
	<string name="reader_label_comments_closed">Komentar ditutup</string>
	<string name="reader_label_comments_on">Komentar pada</string>
	<string name="reader_title_photo_viewer">%1$d dari %2$d</string>
	<string name="error_publish_empty_post">Tidak dapat menerbitkan pos kosong</string>
	<string name="error_refresh_unauthorized_posts">Anda tidak memiliki izin untuk melihat atau menyunting pos</string>
	<string name="error_refresh_unauthorized_pages">Anda tidak memiliki izin untuk melihat atau menyunting halaman</string>
	<string name="error_refresh_unauthorized_comments">Anda tidak memiliki izin untuk melihat atau menyunting komentar</string>
	<string name="older_month">Lebih dari satu bulan</string>
	<string name="more">Lainnya</string>
	<string name="older_two_days">Lebih dari 2 hari</string>
	<string name="older_last_week">Lebih dari satu minggu</string>
	<string name="stats_no_blog">Statistik tidak dapat dimuat untuk blog yang diminta</string>
	<string name="select_a_blog">Pilih situs WordPress</string>
	<string name="sending_content">Mengunggah konten %s</string>
	<string name="uploading_total">Mengunggah %1$d dari %2$d</string>
	<string name="mnu_comment_liked">Disukai</string>
	<string name="comment">Komentar</string>
	<string name="comment_trashed">Komentar dibuang</string>
	<string name="posts_empty_list">Belum ada pos. Mengapa tidak membuatnya?</string>
	<string name="comment_reply_to_user">Balas ke %s</string>
	<string name="pages_empty_list">Belum ada halaman. Mengapa tidak membuatnya?</string>
	<string name="media_empty_list_custom_date">Tidak ada media dalam interval waktu ini</string>
	<string name="posting_post">Mengeposkan "%s"</string>
	<string name="signing_out">Keluar…</string>
	<string name="reader_empty_followed_blogs_title">Anda belum mengikuti situs apapun</string>
	<string name="reader_toast_err_generic">Tidak bisa menjalankan proses ini</string>
	<string name="reader_toast_err_block_blog">Tidak bisa memblokir blog ini</string>
	<string name="reader_toast_blog_blocked">Pos-pos dari blog ini tak akan ditampilkan lagi</string>
	<string name="reader_menu_block_blog">Blokir blog ini</string>
	<string name="contact_us">Hubungi kami</string>
	<string name="hs__conversation_detail_error">Uraikan permasalahan yang Anda hadapi</string>
	<string name="hs__new_conversation_header">Chat dukungan</string>
	<string name="hs__conversation_header">Chat dukungan</string>
	<string name="hs__username_blank_error">Masukkan sebuah nama yang sah</string>
	<string name="hs__invalid_email_error">Masukkan sebuah alamat email yang sah</string>
	<string name="current_location">Lokasi saat ini</string>
	<string name="add_location">Tambahkan lokasi</string>
	<string name="search_location">Cari</string>
	<string name="edit_location">Sunting</string>
	<string name="search_current_location">Temukan</string>
	<string name="preference_send_usage_stats">Kirim statistik</string>
	<string name="preference_send_usage_stats_summary">Secara otomatis mengirim statistik penggunaan untuk membantu kami meningkatkan WordPress untuk Android</string>
	<string name="update_verb">Mutakhirkan</string>
	<string name="schedule_verb">Jadwalkan</string>
	<string name="reader_title_subs">Tag &amp; Blog</string>
	<string name="reader_page_followed_tags">Tag yang diikuti</string>
	<string name="reader_label_followed_blog">Blog diikuti</string>
	<string name="reader_label_tag_preview">Pos dengan tag %s</string>
	<string name="reader_toast_err_get_blog_info">Tak bisa menampilkan blog ini</string>
	<string name="reader_toast_err_already_follow_blog">Anda sudah mengikuti blog ini</string>
	<string name="reader_toast_err_follow_blog">Tak bisa mengikuti blog ini</string>
	<string name="reader_toast_err_unfollow_blog">Tak bisa berhenti mengikuti blog ini</string>
	<string name="reader_empty_recommended_blogs">Tak ada blog yang direkomendasikan</string>
	<string name="reader_title_blog_preview">Blog Pembaca</string>
	<string name="reader_title_tag_preview">Tag Pembaca</string>
	<string name="reader_page_followed_blogs">Situs yang diikuti</string>
	<string name="reader_hint_add_tag_or_url">Masukkan sebuah URL atau tag untuk mengikuti</string>
	<string name="saving">Menyimpan...</string>
	<string name="media_empty_list">Tak ada media</string>
	<string name="ptr_tip_message">Tip: Tarik ke bawah untuk menyegarkan</string>
	<string name="help">Bantuan</string>
	<string name="forgot_password">Lupa password Anda?</string>
	<string name="forums">Forum</string>
	<string name="help_center">Pusat bantuan</string>
	<string name="ssl_certificate_error">Sertifikat SSL tidak sah</string>
	<string name="ssl_certificate_ask_trust">Jika biasanya Anda bisa terhubung dengan situs ini tanpa masalah, galat ini bisa berarti seseorang sedang mencoba meniru situs, dan Anda sebaiknya tidak melanjutkannya. Apakah Anda ingin mempercayai sertifikat ini?</string>
	<string name="no_network_message">Tidak ada jaringan yang tersedia</string>
	<string name="blog_not_found">Terjadi kekeliruan ketika mengakses blog ini</string>
	<string name="wait_until_upload_completes">Tunggu sampai pengunggahan lengkap</string>
	<string name="out_of_memory">Perangkat kehabisan memori.</string>
	<string name="gallery_error">Item media gagal diambil</string>
	<string name="theme_fetch_failed">Gagal mengunduh tema</string>
	<string name="theme_set_failed">Gagal memasang tema</string>
	<string name="comments_empty_list">Tidak ada tanggapan</string>
	<string name="mnu_comment_unspam">Bukan spam</string>
	<string name="no_site_error">Gagal terhubung dengan situs WordPress</string>
	<string name="adding_cat_failed">Gagal menambahkan kategori</string>
	<string name="theme_auth_error_message">Pastikan kamu punya hak untuk mengatur tema</string>
	<string name="adding_cat_success">Berhasil menambahkan kategori</string>
	<string name="cat_name_required">Nama kategori wajib diisi</string>
	<string name="category_automatically_renamed">Nama kategori %1$s tidak sah. Sudah diubah menjadi %2$s.</string>
	<string name="no_account">Akun WordPress tidak ditemukan, masukkan akun dan coba lagi</string>
	<string name="sdcard_message">Kartu SD tambahan diperlukan untuk mengunggah media</string>
	<string name="stats_empty_comments">Belum ada tanggapan</string>
	<string name="stats_bar_graph_empty">Belum ada statistik</string>
	<string name="reply_failed">Gagal mengirim balasan</string>
	<string name="notifications_empty_list">Tak ada pemberitahuan</string>
	<string name="error_delete_post">Terjadi galat saat menghapus %s</string>
	<string name="error_refresh_posts">Pos tidak bisa disegarkan saat ini</string>
	<string name="error_refresh_pages">Laman tidak bisa disegarkan saat ini</string>
	<string name="error_refresh_notifications">Pemberitahuan tidak bisa disegarkan saat ini</string>
	<string name="error_refresh_comments">Tanggapan tidak bisa disegarkan saat ini</string>
	<string name="error_refresh_stats">Statistik tidak bisa disegarkan saat ini</string>
	<string name="error_generic">Terjadi galat</string>
	<string name="error_moderate_comment">Terjadi galat saat sedang memoderasi</string>
	<string name="error_edit_comment">Terjadi galat saat sedang mengedit tanggapan</string>
	<string name="error_upload">Terjadi galat saat sedang mengunggah %s</string>
	<string name="error_load_comment">Gagal memuat tanggapan</string>
	<string name="error_downloading_image">Galat saat mengunduh gambar</string>
	<string name="passcode_wrong_passcode">PIN keliru</string>
	<string name="invalid_email_message">Alamat emailmu tidak sah</string>
	<string name="invalid_password_message">Password harus berisi minimal 4 karakter</string>
	<string name="invalid_username_too_short">Nama pengguna harus lebih dari 4 karakter</string>
	<string name="invalid_username_too_long">Nama pengguna harus kurang dari 61 karakter</string>
	<string name="username_only_lowercase_letters_and_numbers">Nama pengguna hanya boleh mengandung huruf kecil (a-z) dan angka</string>
	<string name="username_required">Masukkan nama pengguna</string>
	<string name="username_not_allowed">Nama pengguna tidak diizinkan</string>
	<string name="username_must_be_at_least_four_characters">Nama pengguna harus lebih dari 4 karakter</string>
	<string name="username_contains_invalid_characters">Nama pengguna tidak boleh mengandung karakter “_”</string>
	<string name="username_must_include_letters">Nama pengguna harus mengandung minimal 1 huruf kecil (a-z)</string>
	<string name="email_invalid">Masukkan alamat email yang sah</string>
	<string name="email_not_allowed">Alamat email itu tidak diizinkan</string>
	<string name="username_exists">Nama pengguna itu sudah terpakai</string>
	<string name="email_exists">Alamat email itu sudah terpakai</string>
	<string name="username_reserved_but_may_be_available">Nama pengguna itu sedang dicadangkan, namun bisa menjadi tersedia dalam beberapa hari</string>
	<string name="blog_name_required">Masukkan alamat situs</string>
	<string name="blog_name_not_allowed">Alamat situs itu tidak diperbolehkan</string>
	<string name="blog_name_must_be_at_least_four_characters">Alamat situs harus memiliki setidaknya 4 karakter</string>
	<string name="blog_name_must_be_less_than_sixty_four_characters">Alamat situs harus kurang dari 64 karakter</string>
	<string name="blog_name_contains_invalid_characters">Alamat situs tidak boleh mengandung karakter “_”</string>
	<string name="blog_name_cant_be_used">Anda tidak diperbolehkan menggunakan alamat situs tersebut</string>
	<string name="blog_name_only_lowercase_letters_and_numbers">Alamat situs hanya boleh mengandung huruf kecil (a-z) dan angka</string>
	<string name="blog_name_exists">Situs itu sudah ada</string>
	<string name="blog_name_reserved">Situs itu dicadangkan</string>
	<string name="blog_name_reserved_but_may_be_available">Situs itu sedang dicadangkan, namun bisa menjadi tersedia dalam beberapa hari</string>
	<string name="username_or_password_incorrect">Nama pengguna atau password yang Anda masukkan tidak tepat</string>
	<string name="nux_cannot_log_in">Kami tak bisa me-log masukkan Anda</string>
	<string name="could_not_remove_account">Gagal menghapus situs</string>
	<string name="invalid_url_message">Pastikan URL yang dimasukkan sudah valid</string>
	<string name="edit_post">Edit tulisan</string>
	<string name="add_comment">Tambahkan komentar</string>
	<string name="connection_error">Galat sambungan</string>
	<string name="cancel_edit">Batalkan edit</string>
	<string name="media_gallery_image_order">Urutan gambar</string>
	<string name="learn_more">Pelajari lebih lanjut</string>
	<string name="xmlrpc_error">Tak bisa tersambung. Masukkan path lengkap ke xmlrpc.php pada situs Anda dan coba lagi.</string>
	<string name="select_categories">Pilih kategori</string>
	<string name="account_details">Rincian Akun</string>
	<string name="post_not_found">Terjadi galat saat memuat pos. Segarkan pos Anda dan coba lagi.</string>
	<string name="media_gallery_settings_title">Pengaturan Galeri</string>
	<string name="media_gallery_num_columns">Jumlah kolom</string>
	<string name="scaled_image_error">Masukkan nilai lebar terskala yang sah</string>
	<string name="media_gallery_edit">Edit galeri</string>
	<string name="media_error_no_permission">Anda tidak memiliki izin untuk melihat pustaka media</string>
	<string name="cannot_delete_multi_media_items">Beberapa media tak bisa dihapus sekarang. Coba lagi nanti.</string>
	<string name="themes_live_preview">Pratinjau langsung</string>
	<string name="theme_current_theme">Tema sekarang</string>
	<string name="theme_premium_theme">Tema premium</string>
	<string name="link_enter_url_text">Teks tautan (opsional)</string>
	<string name="create_a_link">Buat tautan</string>
	<string name="page_settings">Pengaturan laman</string>
	<string name="local_draft">Draf lokal</string>
	<string name="upload_failed">Pengunggahan gagal</string>
	<string name="horizontal_alignment">Perataan horisontal</string>
	<string name="file_not_found">Tidak bisa menemukan media yang hendak diunggah. Apakah sudah dihapus atau dipindahkan?</string>
	<string name="post_settings">Pengaturan pos</string>
	<string name="delete_post">Hapus pos</string>
	<string name="delete_page">Hapus laman</string>
	<string name="comment_status_approved">Diizinkan</string>
	<string name="comment_status_unapproved">Tertunda</string>
	<string name="comment_status_spam">Spam</string>
	<string name="comment_status_trash">Dibuang</string>
	<string name="edit_comment">Edit komentar</string>
	<string name="mnu_comment_approve">Izinkan</string>
	<string name="mnu_comment_unapprove">Tolak</string>
	<string name="mnu_comment_spam">Spam</string>
	<string name="mnu_comment_trash">Tong Sampah</string>
	<string name="dlg_approving_comments">Mengizinkan</string>
	<string name="dlg_unapproving_comments">Menolak</string>
	<string name="dlg_spamming_comments">Menandai sebagai spam</string>
	<string name="dlg_trashing_comments">Membuang ke Tong Sampah</string>
	<string name="dlg_confirm_trash_comments">Buang ke Tong Sampah?</string>
	<string name="trash_yes">Buang</string>
	<string name="trash_no">Jangan buang</string>
	<string name="trash">Tong Sampah</string>
	<string name="author_name">Nama penulis</string>
	<string name="author_email">Email penulis</string>
	<string name="author_url">URL penulis</string>
	<string name="hint_comment_content">Komentar</string>
	<string name="saving_changes">Menyimpan perubahan</string>
	<string name="sure_to_cancel_edit_comment">Batal mengedit komentar ini?</string>
	<string name="content_required">Komentar diwajibkan</string>
	<string name="toast_comment_unedited">Komentar belum berubah</string>
	<string name="delete_draft">Hapus draf</string>
	<string name="preview_page">Pratinjau laman</string>
	<string name="preview_post">Pratinjau pos</string>
	<string name="comment_added">Komentar berhasil ditambahkan</string>
	<string name="page_not_published">Laman belum diterbitkan</string>
	<string name="post_not_published">Pos belum diterbitkan</string>
	<string name="view_in_browser">Tampilkan di peramban</string>
	<string name="add_new_category">Tambahkan kategori baru</string>
	<string name="category_name">Nama kategori</string>
	<string name="category_slug">Slug kategori (opsional)</string>
	<string name="category_desc">Deskripsi kategori (opsional)</string>
	<string name="category_parent">Induk kategori (opsional)</string>
	<string name="share_action_post">Pos baru</string>
	<string name="share_action_media">Pustaka media</string>
	<string name="file_error_create">Tidak bisa membuat berkas temporer untuk pengunggahan media. Pastikan masih cukup ruang di perangkat Anda.</string>
	<string name="open_source_licenses">Lisensi sumber terbuka</string>
	<string name="location_not_found">Lokasi tidak diketahui</string>
	<string name="pending_review">Tinjauan tertunda</string>
	<string name="http_credentials">HTTP credentials (opsional)</string>
	<string name="http_authorization_required">Otorisasi diwajibkan</string>
	<string name="post_format">Format pos</string>
	<string name="new_post">Pos baru</string>
	<string name="new_media">Media baru</string>
	<string name="view_site">Tampilkan situs</string>
	<string name="privacy_policy">Kebijakan privasi</string>
	<string name="local_changes">Perubahan lokal</string>
	<string name="image_settings">Pengaturan gambar</string>
	<string name="add_account_blog_url">Alamat blog</string>
	<string name="wordpress_blog">Blog WordPress</string>
	<string name="error_blog_hidden">Blog ini tersembunyi dan tak bisa dimuat. Aktifkan lagi melalui pengaturan dan coba lagi.</string>
	<string name="fatal_db_error">Terjadi gagal ketika membuat basis data app. Coba instal ulang app.</string>
	<string name="jetpack_message_not_admin">Plugin Jetpack dibutuhkan untuk statistik. Hubungi administrator situs.</string>
	<string name="reader_title_applog">Log aplikasi</string>
	<string name="reader_share_link">Bagikan tautan</string>
	<string name="reader_toast_err_add_tag">Tidak bisa menambahkan tag ini</string>
	<string name="reader_toast_err_remove_tag">Tidak bisa menghapus tag ini</string>
	<string name="required_field">Isian wajib</string>
	<string name="email_hint">Alamat email</string>
	<string name="site_address">Alamat (URL) host mandiri Anda</string>
	<string name="email_cant_be_used_to_signup">Anda tak bisa menggunakan alamat email tersebut untuk mendaftar. Kami bermasalah dengan blokir mereka atas sejumlah email kami. Silakan gunakan layanan email lainnya.</string>
	<string name="email_reserved">Alamat email tersebut telah digunakan. Periksa kotak masuk Anda untuk email aktivasi. Jika Anda tidak mengaktifkannya, Anda masih bisa mencoba lagi dalam beberapa hari.</string>
	<string name="blog_name_must_include_letters">Alamat situs harus memiliki setidaknya 1 huruf (a-z)</string>
	<string name="blog_name_invalid">Alamat situs tidak sah</string>
	<string name="blog_title_invalid">Judul situs tidak sah</string>
	<string name="media_gallery_type_thumbnail_grid">Thumbnail grid</string>
	<string name="blog_removed_successfully">Situs berhasil dihapus</string>
	<string name="remove_account">Hapus situs</string>
	<string name="notifications_empty_all">Belum ada pemberitahuan...sampai sekarang.</string>
	<string name="invalid_site_url_message">Pastikan URL situs yang dimasukkan sudah valid</string>
	<string name="deleting_page">Menghapus laman</string>
	<string name="deleting_post">Menghapus pos</string>
	<string name="share_url_post">Bagikan pos</string>
	<string name="share_url_page">Bagikan laman</string>
	<string name="share_link">Bagikan tautan</string>
	<string name="creating_your_account">Membuat akun Anda</string>
	<string name="creating_your_site">Membuat situs Anda</string>
	<string name="reader_empty_posts_in_tag_updating">Mengambil pos...</string>
	<string name="error_refresh_media">Ada sesuatu yang salah saat menyegarkan pustaka media. Coba lagi nanti.</string>
	<string name="reader_likes_you_and_multi">Anda dan %,d lainnya menyukai ini</string>
	<string name="reader_likes_multi">%,d orang menyukai ini</string>
	<string name="reader_toast_err_get_comment">Tak bisa menampilkan komentar ini</string>
	<string name="reader_label_reply">Balas</string>
	<string name="video">Video</string>
	<string name="download">Mengunduh media</string>
	<string name="cant_share_no_visible_blog">Anda tidak bisa berbagi ke WordPress tanpa satupun blog yang terlihat oleh publik</string>
	<string name="comment_spammed">Komentar ditandai sebagai spam</string>
	<string name="select_time">Pilih waktu</string>
	<string name="reader_likes_you_and_one">Anda dan satu orang lainnya menyukai ini</string>
	<string name="select_date">Pilih tanggal</string>
	<string name="pick_photo">Pilih foto</string>
	<string name="account_two_step_auth_enabled">Akun ini memiliki sistem autentifikasi dua langkah yang aktif. Kunjungi pengaturan keamanan Anda di WordPress.com dan buat password khusus untuk aplikasi.</string>
	<string name="pick_video">Pilih video</string>
	<string name="reader_toast_err_get_post">Gagal membuka pos ini</string>
	<string name="validating_user_data">Memeriksa keabsahan data pengguna</string>
	<string name="validating_site_data">Memeriksa keabsahan data situs</string>
	<string name="reader_empty_followed_blogs_description">Tapi jangan khawatir, cukup ketuk ikon di kanan atas untuk mulai menjelajah!</string>
	<string name="password_invalid">Anda butuh password yang lebih aman. Pastikan menggunakan 7 atau lebih karakter, kombinasikan huruf kapital dan kecil, angka atau tanda baca.</string>
	<string name="nux_tap_continue">Lanjutkan</string>
	<string name="nux_welcome_create_account">Buat akun</string>
	<string name="nux_add_selfhosted_blog">Tambahkan situs dengan hostiing mandiri</string>
	<string name="nux_oops_not_selfhosted_blog">Masuk ke WordPress.com</string>
	<string name="signing_in">Masuk…</string>
	<string name="media_add_popup_title">Tambah ke pustaka media</string>
	<string name="media_add_new_media_gallery">Buat album</string>
	<string name="empty_list_default">List ini masih kosong</string>
	<string name="select_from_media_library">Pilih dari pustaka media</string>
	<string name="jetpack_message">Plugin Jetpack diperlukan untuk Statistik. Apakah anda akan menginstall Jetpack ?</string>
	<string name="jetpack_not_found">Plugin Jetpack tidak ditemukan</string>
	<string name="reader_untitled_post">(Tanpa Judul)</string>
	<string name="reader_share_subject">di sebarkan dari %s</string>
	<string name="reader_btn_share">Bagikan</string>
	<string name="reader_btn_follow">Ikuti</string>
	<string name="reader_btn_unfollow">Pengikut</string>
	<string name="reader_label_added_tag">%s ditambahkan</string>
	<string name="reader_label_removed_tag">%s dihapus</string>
	<string name="reader_likes_one">Satu orang menyukai ini</string>
	<string name="reader_likes_only_you">Anda menyukai ini</string>
	<string name="reader_toast_err_comment_failed">Tidak bisa menambahkan komentar anda</string>
	<string name="reader_toast_err_tag_exists">Anda telah mengikuti tag ini</string>
	<string name="reader_toast_err_tag_invalid">Tag ini tidak valid</string>
	<string name="reader_toast_err_share_intent">Tidak dapat membagikan</string>
	<string name="reader_toast_err_view_image">Tidak dapat melihat gambar</string>
	<string name="reader_toast_err_url_intent">Tidak bisa  membuka %s</string>
	<string name="reader_empty_followed_tags">Anda belum mengikuti satupun tag</string>
	<string name="create_account_wpcom">Buat akun dengan Wordpress.com</string>
	<string name="connecting_wpcom">MEnghubungkan ke Wordpress.com</string>
	<string name="username_invalid">Username tidak valid</string>
	<string name="limit_reached">Mencapai batasan. Anda dapat mencoba kembali setelah 1 menit. Cobalah kembali, ini akan menambahkan kesempatan kepada anda sebelum benar-benar masuk list banned. Jika menurut anda ini adalah suatu kesalahan, hubungi Support.</string>
	<string name="nux_tutorial_get_started_title">Memulai!</string>
	<string name="reader_hint_comment_on_comment">Balas komentar…</string>
	<string name="button_next">Selanjutnya</string>
	<string name="all">Semua</string>
	<string name="images">Gambar</string>
	<string name="themes">Tema</string>
	<string name="custom_date">Tanggal Tersuai</string>
	<string name="unattached">Tidak terlampir</string>
	<string name="media_add_popup_capture_photo">Ambil foto</string>
	<string name="media_add_popup_capture_video">Rekam video</string>
	<string name="media_edit_title_text">Judul</string>
	<string name="media_edit_caption_text">Subjudul</string>
	<string name="media_edit_description_text">Deskripsi</string>
	<string name="media_edit_title_hint">Masukkan judul di sini</string>
	<string name="media_edit_caption_hint">Masukkan subjudul di sini</string>
	<string name="media_edit_description_hint">Masukkan deskripsi di sini</string>
	<string name="media_edit_success">Telah diperbarui</string>
	<string name="media_gallery_image_order_random">Acak</string>
	<string name="media_gallery_image_order_reverse">Terbalik</string>
	<string name="media_gallery_type">Tipe</string>
	<string name="media_gallery_type_squares">Kotak-kotak</string>
	<string name="media_gallery_type_tiled">Tersusun</string>
	<string name="media_gallery_type_circles">Lingkaran</string>
	<string name="media_gallery_type_slideshow">Slide</string>
	<string name="media_edit_failure">Gagal memperbarui</string>
	<string name="themes_details_label">Detil</string>
	<string name="themes_features_label">Fitur</string>
	<string name="theme_activate_button">Aktivasi</string>
	<string name="theme_activating_button">Mengaktivasi</string>
	<string name="theme_set_success">Berhasil memasang tema!</string>
	<string name="theme_auth_error_title">Gagal mengambil tema</string>
	<string name="stats_view_clicks">Klik</string>
	<string name="stats_view_tags_and_categories">Tag &amp; Kategori</string>
	<string name="stats_view_referrers">Pengacu</string>
	<string name="stats_timeframe_today">Hari Ini</string>
	<string name="stats_timeframe_yesterday">Kemarin</string>
	<string name="post_excerpt">Rangkuman</string>
	<string name="share_action_title">Tambah ke ...</string>
	<string name="share_action">Bagi</string>
	<string name="stats">Stat</string>
	<string name="stats_view_visitors_and_views">Pengunjung dan Tampilan</string>
	<string name="stats_totals_views">Tampilan</string>
	<string name="stats_totals_clicks">Klik</string>
	<string name="stats_totals_plays">Pemutaran</string>
	<string name="stats_timeframe_days">Hari</string>
	<string name="stats_timeframe_weeks">Minggu</string>
	<string name="stats_timeframe_months">Bulan</string>
	<string name="stats_entry_country">Negara</string>
	<string name="stats_entry_posts_and_pages">Judul</string>
	<string name="stats_entry_tags_and_categories">Topik</string>
	<string name="stats_entry_authors">Penulis</string>
	<string name="stats_entry_referrers">Pengacu</string>
	<string name="passcode_set">Pasang PIN</string>
	<string name="passcode_preference_title">Kunci PIN</string>
	<string name="passcode_turn_off">Matikan kunci PIN</string>
	<string name="passcode_turn_on">Nyalakan kunci PIN</string>
	<string name="passcode_manage">Atur kunci PIN</string>
	<string name="passcode_enter_passcode">Masukkan PIN Anda</string>
	<string name="passcode_enter_old_passcode">Masukkan PIN lama Anda</string>
	<string name="passcode_re_enter_passcode">Masukkan kembali PIN Anda</string>
	<string name="passcode_change_passcode">Ubah PIN</string>
	<string name="upload">Unggah</string>
	<string name="discard">Batal</string>
	<string name="notifications">Notifikasi</string>
	<string name="note_reply_successful">Balasan telah terbit</string>
	<string name="new_notifications">%d notifikasi baru</string>
	<string name="more_notifications">dan %d lagi.</string>
	<string name="sign_in">Log masuk</string>
	<string name="follows">Mengikuti</string>
	<string name="loading">Memuat...</string>
	<string name="httpuser">Nama pengguna HTTP</string>
	<string name="httppassword">Kata sandi HTTP</string>
	<string name="error_media_upload">Ada masalah ketika mengunggah media</string>
	<string name="content_description_add_media">Tambah media</string>
	<string name="publish_date">Terbitkan</string>
	<string name="post_content">Konten (tekan untuk menambah teks dan media)</string>
	<string name="incorrect_credentials">Nama pengguna atau kata sandi salah.</string>
	<string name="password">Kata sandi</string>
	<string name="username">Nama pengguna</string>
	<string name="reader">Pembaca</string>
	<string name="post">Terbitkan</string>
	<string name="no_network_title">Tidak ada jaringan</string>
	<string name="page">Halaman</string>
	<string name="pages">Halaman</string>
	<string name="caption">Subjudul (opsional)</string>
	<string name="width">Lebar</string>
	<string name="posts">Tulisan</string>
	<string name="anonymous">Anonim</string>
	<string name="featured">Gunakan sebagai gambar terfitur</string>
	<string name="featured_in_post">Sertakan gambar dalam konten tulisan</string>
	<string name="blogusername">blogusername</string>
	<string name="ok">OK</string>
	<string name="upload_scaled_image">Unggah dan tautkan ke gambar terskala</string>
	<string name="scaled_image">Lebar gambar terskala</string>
	<string name="scheduled">Dijadwalkan</string>
	<string name="link_enter_url">URL</string>
	<string name="uploading">Mengunggah...</string>
	<string name="version">Versi</string>
	<string name="app_title">WordPress untuk Android</string>
	<string name="tos">Syarat Layanan</string>
	<string name="max_thumbnail_px_width">Lebar Gambar Baku</string>
	<string name="image_alignment">Penjajaran</string>
	<string name="refresh">Segarkan</string>
	<string name="untitled">Tanpa judul</string>
	<string name="edit">Sunting</string>
	<string name="post_id">Tulisan</string>
	<string name="page_id">Halaman</string>
	<string name="post_password">Kata sandi (opsional)</string>
	<string name="immediately">Segera</string>
	<string name="quickpress_add_alert_title">Tentukan nama pintasan</string>
	<string name="today">Hari ini</string>
	<string name="settings">Pengaturan</string>
	<string name="share_url">Berbagi URL</string>
	<string name="quickpress_window_title">Pilih blog untuk pintasan QuickPress</string>
	<string name="quickpress_add_error">Nama pintasan tidak boleh kosong</string>
	<string name="publish_post">Publikasi</string>
	<string name="draft">Naskah</string>
	<string name="post_private">Privat</string>
	<string name="upload_full_size_image">Unggah dan tautkan ke gambar ukuran penuh</string>
	<string name="categories">Kategori</string>
	<string name="title">Judul</string>
	<string name="tags_separate_with_commas">Tag (pisahkan tag dengan tanda koma)</string>
	<string name="dlg_deleting_comments">Menghapus komentar</string>
	<string name="notification_vibrate">Getar</string>
	<string name="notification_blink">Lampu notifikasi berkelip</string>
	<string name="notification_sound">Bunyi notifikasi</string>
	<string name="status">Status</string>
	<string name="select_video">Pilih video dari galeri</string>
	<string name="sdcard_title">Dibutuhkan SD Card</string>
	<string name="location">Lokasi</string>
	<string name="media">Media</string>
	<string name="delete">Hapus</string>
	<string name="none">Tiada</string>
	<string name="blogs">Blog</string>
	<string name="select_photo">Pilih sebuah foto dari galeri</string>
	<string name="reply">Balasan</string>
	<string name="preview">Pratinjau</string>
	<string name="on">pada</string>
	<string name="cancel">Batal</string>
	<string name="save">Simpan</string>
	<string name="add">Tambah</string>
	<string name="yes">Ya</string>
	<string name="no">Tidak</string>
	<string name="error">Galat</string>
	<string name="category_refresh_error">Gagal memuat ulang Kategori</string>
	<string name="notification_settings">Pengaturan Pemberitahuan</string>
</resources>
