<?xml version="1.0" encoding="utf-8"?>
<resources>
	<string name="error_fetch_users_list">Tidak boleh mendapatkan pengguna laman</string>
	<string name="plans_manage">Urus pelan anda di\nWordPress.com/plans</string>
	<string name="title_follower">Pengikut</string>
	<string name="title_email_follower">Pengikut Emel</string>
	<string name="people_empty_list_filtered_viewers">Anda belum mempunyai penonton.</string>
	<string name="people_empty_list_filtered_email_followers">Anda belum mempunyai pengikut emel.</string>
	<string name="people_empty_list_filtered_followers">Anda belum mempunyai pengikut.</string>
	<string name="people_empty_list_filtered_users">Anda belum mempunyai pengguna.</string>
	<string name="people_dropdown_item_viewers">Penonton</string>
	<string name="people_dropdown_item_email_followers">Pengikut Emel</string>
	<string name="people_dropdown_item_followers">Pengikut</string>
	<string name="people_dropdown_item_team">Pasukan</string>
	<string name="invite_message_usernames_limit">Jemput sehingga 10 alamat emel dan/atau nama pengguna WordPress.com. Mereka yang memerlukan nama pengguna akan dihantar arahan tentang bagaimana untuk mewujudkannya.</string>
	<string name="viewer_remove_confirmation_message">Jika anda membuang penonton ini, beliau tidak akan dapat melawat laman ini.\n\nAnda masih ingin membuang penonton ini?</string>
	<string name="follower_remove_confirmation_message">Jika dibuang, pengikut ini akan berhenti menerima pemberitahuan tentang laman ini, kecuali jika mereka mengikut kembali.\n\nAnda masih ingin membuang pengikut 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">Tidak dapat membuang pengikut</string>
	<string name="error_remove_viewer">Tidak dapat membuang penonton</string>
	<string name="error_fetch_email_followers_list">Tidak boleh mendapatkan pengikut emel laman</string>
	<string name="error_fetch_followers_list">Tidak boleh mendapatkan pengikut laman</string>
	<string name="editor_failed_uploads_switch_html">Sebahagian muat naik media telah gagal. Anda tidak boleh menukar ke mod HTML\ndalam keadaan ini. in this state. Buang semua muat naik yang gagal dan bersambung?</string>
	<string name="format_bar_description_html">Mod HTML</string>
	<string name="visual_editor">Penyunting visual</string>
	<string name="image_thumbnail">Imej kecil</string>
	<string name="format_bar_description_ul">Senarai tidak tertib</string>
	<string name="format_bar_description_ol">Senarai tertib</string>
	<string name="format_bar_description_media">Sisip media</string>
	<string name="format_bar_description_more">Sisip selanjutnya</string>
	<string name="format_bar_description_strike">Garis batal</string>
	<string name="format_bar_description_quote">Petikan blok</string>
	<string name="format_bar_description_link">Sisip pautan</string>
	<string name="format_bar_description_italic">Italik</string>
	<string name="format_bar_description_underline">Garis bawah</string>
	<string name="image_caption">Sari Kata</string>
	<string name="image_alt_text">Teks alt</string>
	<string name="image_link_to">Paut ke</string>
	<string name="image_width">Lebar</string>
	<string name="format_bar_description_bold">Tebal</string>
	<string name="image_settings_save_toast">Penukaran disimpan</string>
	<string name="image_settings_dismiss_dialog_title">Buang penukaran yang tidak disimpan?</string>
	<string name="stop_upload_dialog_title">Berhenti memuat naik?</string>
	<string name="stop_upload_button">Berhenti Muat Naik</string>
	<string name="alert_error_adding_media">Ralat berlaku semasa menyisip media</string>
	<string name="alert_action_while_uploading">Anda sedang memuat naik media. Sila tunggu sehingga ianya selesai.</string>
	<string name="alert_insert_image_html_mode">Tidak dapat menyisip media terus dalam mod HTML. Sila tukar kembali ke mod visual.</string>
	<string name="uploading_gallery_placeholder">Memuat naik galeri...</string>
	<string name="invite_error_for_username">%1$s: %2$s</string>
	<string name="invite_error_some_failed">Jemputan dihantar tetapi ralat berlaku!</string>
	<string name="invite_sent">Jemputan berjaya dihantar</string>
	<string name="tap_to_try_again">Ketik untuk cuba semula!</string>
	<string name="invite_error_sending">Ralat berlaku semasa cuba menghantar jemputan!</string>
	<string name="invite_error_invalid_usernames_multiple">Tidak dapat menghantar: Terdapat nama pengguna atau emel yang tidak sah</string>
	<string name="invite_error_invalid_usernames_one">Tidak dapat menghantar: Nama pengguna atau emel adalah tidak sah</string>
	<string name="invite_error_no_usernames">Sila tambah sekurang-kurangnya satu nama pengguna</string>
	<string name="invite_message_info">(Pilihan) Anda boleh memasukkan mesej tersuai sehingga 500 aksara yang akan disertakan dalam jemputan kepada pengguna.</string>
	<string name="invite_message_remaining_other">Tinggal %d aksara</string>
	<string name="invite_message_remaining_one">Tinggal 1 aksara</string>
	<string name="invite_message_remaining_zero">Tinggal 0 aksara</string>
	<string name="invite_invalid_email">Alamat emel \'%s\' tidak sah</string>
	<string name="invite_message_title">Mesej Tersuai</string>
	<string name="invite_already_a_member">Sudah terdapat ahli dengan nama pengguna \'%s\'</string>
	<string name="invite_username_not_found">Tiada pengguna dijumpai bagi nama pengguna \'%s\'</string>
	<string name="invite">Jemput</string>
	<string name="invite_names_title">Nama Pengguna atau Emel</string>
	<string name="signup_succeed_signin_failed">Akaun anda telah direka tetapi ralat berlaku semasa kami melog anda\nmasuk. Sila log masuk dengan nama pengguna dan kata laluan baharu anda.</string>
	<string name="send_link">Hantar pautan</string>
	<string name="my_site_header_external">Luaran</string>
	<string name="invite_people">Jemput Orang</string>
	<string name="label_clear_search_history">Kosongkan sejarah carian</string>
	<string name="dlg_confirm_clear_search_history">Kosongkan sejarah carian?</string>
	<string name="reader_empty_posts_in_search_description">Tiada kiriman dijumpai untuk %s bagi bahasa anda</string>
	<string name="reader_label_post_search_running">Mencari...</string>
	<string name="reader_label_related_posts">Bacaan Berkaitan</string>
	<string name="reader_empty_posts_in_search_title">Tiada kiriman ditemui</string>
	<string name="reader_label_post_search_explainer">Cari semua blog umum WordPress.com</string>
	<string name="reader_hint_post_search">Cari WordPress.com</string>
	<string name="reader_title_search_results">Carian untuk %s</string>
	<string name="reader_title_related_post_detail">Kiriman Berkaitan</string>
	<string name="preview_screen_links_disabled">Pautan dinyah boleh pada skrin pratonton</string>
	<string name="draft_explainer">Kiriman ini adalah draf yang belum diterbitkan</string>
	<string name="send">Hantar</string>
	<string name="person_removed">Berjaya membuang %1$s</string>
	<string name="user_remove_confirmation_message">Jika anda membuang %1$s, pengguna berkenaan tidak lagi akan dapat mencapai laman ini, tetapi apa-apa kandungan yang diwujudkan oleh %1$s akan tetap berada pada laman berkenaan.\n\nAnda ingin membuang pengguna ini?</string>
	<string name="person_remove_confirmation_title">Buang %1$s</string>
	<string name="edit_user">Sunting Pengguna</string>
	<string name="role">Peranan</string>
	<string name="people">Orang</string>
	<string name="reader_empty_posts_in_custom_list">Laman dalam senarai ini tiada kiriman baharu.</string>
	<string name="error_remove_user">Tidak dapat membuang pengguna</string>
	<string name="error_fetch_viewers_list">Tidak boleh mendapatkan penonton laman</string>
	<string name="error_update_role">Tidak dapat mengemaskini peranan pengguna</string>
	<string name="gravatar_camera_and_media_permission_required">Kebenaran diperlukan untuk memilih atau menangkap gambar</string>
	<string name="error_updating_gravatar">Ralat mengemaskini Gravatar anda</string>
	<string name="error_refreshing_gravatar">Ralat memuatkan Gravatar anda</string>
	<string name="error_locating_image">Ralat mencari imej dipangkas</string>
	<string name="gravatar_tip">Baharu! Ketik Gravatar anda untuk menukarnya!</string>
	<string name="error_cropping_image">Ralat memangkas imej</string>
	<string name="checking_email">Menyemak emel</string>
	<string name="launch_your_email_app">Lancarkan aplikasi emel anda</string>
	<string name="not_on_wordpress_com">Tidak dalam WordPress.com?</string>
	<string name="check_your_email">Semak emel anda</string>
	<string name="magic_link_unavailable_error_message">Tidak terdapat pada masa ini. Sila masukkan kata laluan anda</string>
	<string name="get_a_link_sent_to_your_email_to_sign_in_instantly">Dapatkan pautan dihantar ke emel anda untuk daftar masuk segera</string>
	<string name="logging_in">Melog masuk</string>
	<string name="enter_your_password_instead">Sebaliknya masukkan kata laluan anda</string>
	<string name="web_address_dialog_hint">Tunjukkan kepada umum apabila anda mengulas.</string>
	<string name="username_email">Emel atau nama pengguna</string>
	<string name="jetpack_not_connected_message">Pemalam Jetpack telah dipasang, tetapi tidak dihubungkan ke WordPress.com. Adakah anda ingin menghubungkan Jetpack?</string>
	<string name="jetpack_not_connected">Pemalam Jetpack tidak dihubungkan</string>
	<string name="new_editor_reflection_error">Penyunting visual tidak serasi dengan peranti anda. Ia dinyah boleh\nsecara automatik</string>
	<string name="stats_insights_latest_post_no_title">(tiada tajuk)</string>
	<string name="capture_or_pick_photo">Tangkap atau pilih gambar</string>
	<string name="plans_post_purchase_text_themes">Anda kini mempunyai capaian tanpa had ke tema Premium. Pratonton mana-mana tema pada laman anda untuk bermula.</string>
	<string name="plans_post_purchase_button_themes">Layari Tema</string>
	<string name="plans_post_purchase_title_themes">Cari tema premium dan sempurna</string>
	<string name="plans_post_purchase_button_video">Mulakan kiriman baharu</string>
	<string name="plans_post_purchase_text_video">Anda boleh muatnaik dan hoskan video di laman anda dengan VideoPress dan storan media anda yang dibesarkan.</string>
	<string name="plans_post_purchase_title_video">Hidupkan kiriman dengan video</string>
	<string name="plans_post_purchase_button_customize">Suai Langgan Laman saya</string>
	<string name="plans_post_purchase_text_customize">Anda kini mempunyai capaian ke fon tersuai, warna tersuai, dan ciri-ciri penyuntingan CSS tersuai.</string>
	<string name="plans_post_purchase_text_intro">Laman anda sedang melompat kegembiraan! Sekarang lihat ciri-ciri baharu laman anda dan pilih dimana anda ingin mulakan.</string>
	<string name="plans_post_purchase_title_customize">Suai Langgan Fon &amp; Warna</string>
	<string name="plans_post_purchase_title_intro">Semuanya milik anda, sangat bagus!</string>
	<string name="export_your_content_message">Kiriman, halaman, dan tetapan anda akan diemel kepada anda di %s.</string>
	<string name="plan">Pelan</string>
	<string name="plans">Pelan</string>
	<string name="plans_loading_error">Tidak boleh memuatkan pelan</string>
	<string name="export_your_content">Eksport kandungan anda</string>
	<string name="export_email_sent">Emel eksport dihantar!</string>
	<string name="exporting_content_progress">Mengeksport kandungan...</string>
	<string name="premium_upgrades_message">Anda mempunyai naik taraf premium aktif di laman anda. Sila batalkan naik taraf anda sebelum menghapuskan laman anda.</string>
	<string name="show_purchases">Tunjukkan pembelian</string>
	<string name="checking_purchases">Menyemak pembelian</string>
	<string name="premium_upgrades_title">Naiktaraf Premium</string>
	<string name="purchases_request_error">Sesuatu tidak kena. Tidak boleh memohon pembelian</string>
	<string name="delete_site_progress">Menghapus laman...</string>
	<string name="delete_site_hint">Padamkan laman</string>
	<string name="delete_site_summary">Tindakan ini tidak boleh diulang semula. Menghapuskan laman anda akan membuang semua kandungan, penyumbang, dan domain dari laman.</string>
	<string name="are_you_sure">Anda Pasti?</string>
	<string name="export_site_hint">Eksport laman anda ke fail XML</string>
	<string name="export_site_summary">Jika anda pasti, pastikan anda mengambil masa dan eksport kandungan sekarang. Ia tidak boleh didapati semula.</string>
	<string name="keep_your_content">Simpan Kandungan Anda</string>
	<string name="domain_removal_hint">Domain yang tidak akan berfungsi jika anda membuang laman anda</string>
	<string name="domain_removal_summary">Berhat-hati! Menghapuskan laman anda juga akan membuang domain anda yang disenaraikan di bawah.</string>
	<string name="primary_domain">Domain Utama</string>
	<string name="domain_removal">Pembuangan Domain</string>
	<string name="error_deleting_site_summary">Terdapat ralat ketika menghapuskan laman anda. Sila hubungi sokongan untuk bantuan lanjut</string>
	<string name="error_deleting_site">Ralat untuk memadamkan laman</string>
	<string name="site_settings_export_content_title">Eksport isi kandungan</string>
	<string name="confirm_delete_site_prompt">Sila taipkan %1$s dalam medan di bawah untuk mengesahkan. Laman anda akan hilang selamanya.</string>
	<string name="contact_support">Hubungi sokongan</string>
	<string name="confirm_delete_site">Sah Hapuskan Laman</string>
	<string name="start_over_text">Jika anda mahukan laman tapi tidak mahu apa-apa kiriman atau laman yang anda ada sekarang, kumpulan sokongan kami boleh menghapuskan kiriman, halaman, media dan komen untuk anda.\n\nIni akan mengekalkan status aktif laman dan URL anda, tetapi memberi anda permulaan baharu untuk mewujudkan kandungan. Hubungi kami untuk menghapuskan kandungan semasa anda.</string>
	<string name="let_us_help">Biar Kami Bantu</string>
	<string name="site_settings_start_over_hint">Mulakan semula laman anda</string>
	<string name="me_btn_app_settings">Tetapan Aplikasi</string>
	<string name="start_over">Mula Semula</string>
	<string name="editor_remove_failed_uploads">Buangkan muatnaik yang gagal</string>
	<string name="editor_toast_failed_uploads">Sebahagian muatnaik media telah gagal. Anda tidak boleh menyimpan atau menerbitkan\n        kiriman anda dalam keadaan ini. Adakah anda ingin membuang semua muatnaik media yang gagal?</string>
	<string name="site_settings_advanced_header">Lanjutan</string>
	<string name="comments_empty_list_filtered_trashed">Tiada ulasan dibuang</string>
	<string name="comments_empty_list_filtered_pending">Tiada komen tertangguh</string>
	<string name="comments_empty_list_filtered_approved">Tiada ulasan yang diluluskan</string>
	<string name="button_done">Selesai</string>
	<string name="button_skip">Langkau</string>
	<string name="site_timeout_error">Tidak dapat menghubungi laman WordPress kerana ralat Timeout.</string>
	<string name="xmlrpc_malformed_response_error">Tidak boleh berhubung. Pemasangan WordPress membalas dengan dokumen XML-RPC yang tidak sah.</string>
	<string name="xmlrpc_missing_method_error">Tidak boleh berhubung. Kaedah XML-RPC yang diperlukan tiada pada pelayan.</string>
	<string name="theme_all">Semua</string>
	<string name="post_format_status">Status</string>
	<string name="post_format_video">Video</string>
	<string name="theme_premium">Premium</string>
	<string name="theme_free">Percuma</string>
	<string name="post_format_image">Imej</string>
	<string name="post_format_chat">Perbualan</string>
	<string name="post_format_link">Pautan</string>
	<string name="post_format_gallery">Galeri</string>
	<string name="post_format_quote">Petikan</string>
	<string name="post_format_standard">Piawai</string>
	<string name="post_format_aside">Sisipan</string>
	<string name="post_format_audio">Audio</string>
	<string name="notif_events">Maklumat kursus dan acara di WordPress.com (atas talian &amp; perseorangan).</string>
	<string name="notif_surveys">Peluang untuk terlibat dalam kajian &amp; kaji selidik WordPress.com.</string>
	<string name="notif_tips">Tip untuk mendapat yang terbaik dari WordPress.com.</string>
	<string name="notif_community">Komuniti</string>
	<string name="notif_suggestions">Cadangan</string>
	<string name="notif_research">Kajian</string>
	<string name="replies_to_my_comments">Balasan kepada ulasan saya</string>
	<string name="site_achievements">Pencapaian laman</string>
	<string name="username_mentions">Nama pengguna yang disebut</string>
	<string name="likes_on_my_posts">Suka pada kiriman saya</string>
	<string name="site_follows">Laman diikuti</string>
	<string name="likes_on_my_comments">Suka pada ulasan saya</string>
	<string name="comments_on_my_site">Ulasan pada laman saya</string>
	<string name="site_settings_list_editor_summary_other">%d butir</string>
	<string name="site_settings_list_editor_summary_one">1 butir</string>
	<string name="approve_auto">Semua pengguna</string>
	<string name="approve_auto_if_previously_approved">Ulasan pengguna dikenali</string>
	<string name="approve_manual">Tiada ulasan</string>
	<string name="site_settings_paging_summary_other">%d ulasan setiap halaman</string>
	<string name="site_settings_paging_summary_one">1 ulasan setiap halaman</string>
	<string name="site_settings_multiple_links_summary_other">Perlukan kelulusan untuk lebih dari %d pautan</string>
	<string name="site_settings_multiple_links_summary_one">Perlukan kelulusan untuk lebih dari 1 pautan</string>
	<string name="site_settings_multiple_links_summary_zero">Perlukan kelulusan untuk lebih dari 0 pautan</string>
	<string name="detail_approve_auto">Luluskan ulasan semua secara automatik.</string>
	<string name="detail_approve_auto_if_previously_approved">Luluskan secara automatik sekiranya pengguna mempunyai ulasan yang diluluskan sebelum ini</string>
	<string name="detail_approve_manual">Perlukan kelulusan manual bagi ulasan semua orang.</string>
	<string name="days_quantity_other">%d hari</string>
	<string name="days_quantity_one">1 hari</string>
	<string name="filter_trashed_posts">Disampahkan</string>
	<string name="filter_scheduled_posts">Dijadualkan</string>
	<string name="filter_draft_posts">Draf</string>
	<string name="filter_published_posts">Diterbitkan</string>
	<string name="web_address">Alamat Web</string>
	<string name="primary_site">Laman utama</string>
	<string name="pending_email_change_snackbar">Klik pautan pengesahan dalam emel yang dihantar ke %1$s untuk mengesahkan alamat baharu anda</string>
	<string name="editor_toast_uploading_please_wait">Anda sedang memuatnaik media. Sila tunggu sehingga selesai.</string>
	<string name="error_refresh_comments_showing_older">Ulasan tidak dapat disegarkan buat masa ini - tunjukkan ulasan terdahulu</string>
	<string name="editor_post_settings_set_featured_image">Tetapkan Imej Terencana</string>
	<string name="editor_post_settings_featured_image">Imej Terencana</string>
	<string name="new_editor_promo_desc">Aplikasi WordPress untuk Android kini dilengkapi dengan penyunting\n    visual baharu yang cantik. Cubanya dengan membuat kiriman baharu.</string>
	<string name="new_editor_promo_title">Penyuntung baharu</string>
	<string name="new_editor_promo_button_label">Hebat, terima kasih!</string>
	<string name="visual_editor_enabled">Penyunting Visual dibolehkan</string>
	<string name="editor_content_placeholder">Kongsikan cerita anda di sini...</string>
	<string name="editor_page_title_placeholder">Tajuk Halaman</string>
	<string name="editor_post_title_placeholder">Tajuk Kiriman</string>
	<string name="email_address">Alamat emel</string>
	<string name="preference_show_visual_editor">Tunjukkan penyunting visual</string>
	<string name="preference_editor">Penyunting</string>
	<string name="dlg_sure_to_delete_comments">Hapuskan ulasan ini secara kekal?</string>
	<string name="dlg_sure_to_delete_comment">Hapuskan ulasan ini secara kekal?</string>
	<string name="mnu_comment_delete_permanently">Hapus</string>
	<string name="comment_deleted_permanently">Ulasan dihapuskan</string>
	<string name="mnu_comment_untrash">Pulihkan</string>
	<string name="comments_empty_list_filtered_spam">Tiada ulasan Spam</string>
	<string name="comment_status_all">Semua</string>
	<string name="could_not_load_page">Tidak dapat memuatkan halaman</string>
	<string name="off">Matikan</string>
	<string name="interface_language">Bahasa Antara Muka</string>
	<string name="about_the_app">Mengenai aplikasi</string>
	<string name="error_post_account_settings">Tidak boleh menyimpan tetapan akaun anda</string>
	<string name="error_post_my_profile">Tidak dapat menyimpan profil anda</string>
	<string name="error_fetch_account_settings">Tidak boleh mendapatkan tetapan akaun anda</string>
	<string name="error_fetch_my_profile">Tidak boleh mendapatkan profil anda</string>
	<string name="stats_widget_promo_ok_btn_label">Ok, faham</string>
	<string name="stats_widget_promo_desc">Tambah widget ke skrin muka depan anda untuk mencapai Statistik anda dalam satu klik.</string>
	<string name="stats_widget_promo_title">Widget Statistik Skrin Laman Utama</string>
	<string name="site_settings_unknown_language_code_error">Kod bahasa tidak dikenali</string>
	<string name="site_settings_threading_dialog_description">Benarkan ulasan disarang dalam jalur.</string>
	<string name="site_settings_threading_dialog_header">Jalur sehingga</string>
	<string name="add_category">Tambah kategori</string>
	<string name="remove">Buang</string>
	<string name="disabled">Nyah boleh</string>
	<string name="search">Cari</string>
	<string name="site_settings_image_original_size">Saiz Asal</string>
	<string name="privacy_private">Laman anda adalah kelihatan hanya kepada anda dan pengguna yang anda luluskan</string>
	<string name="privacy_public_not_indexed">Laman anda adalah kelihatan kepada semua tetapi meminta enjin carian untuk tidak mengindeksnya</string>
	<string name="privacy_public">Laman anda adalah kelihata kepada semua dan mungkin diindeks oleh enjin carian</string>
	<string name="about_me_hint">Beberapa perkataan mengenai anda...</string>
	<string name="about_me">Mengenai saya</string>
	<string name="public_display_name_hint">Nama paparan akan kembali kepada nama pengguna anda jika ia tidak ditetapkan</string>
	<string name="public_display_name">Nama paparan umum</string>
	<string name="last_name">Nama akhir</string>
	<string name="first_name">Nama pertama</string>
	<string name="my_profile">Profil Saya</string>
	<string name="site_privacy_public_desc">Benarkan enjin carian untuk mengindeks laman ini</string>
	<string name="site_privacy_hidden_desc">Jangan galakkan enjin carian daripada mengindeks laman ini</string>
	<string name="site_privacy_private_desc">Saya mahu laman saya menjadi sulit, boleh dilihat hanya kepada pengguna yang saya pilih</string>
	<string name="cd_related_post_preview_image">Imej pratonton kiriman berkaitan</string>
	<string name="error_post_remote_site_settings">Tidak boleh menyimpan maklumat laman</string>
	<string name="error_fetch_remote_site_settings">Tidak boleh mendapatkan maklumat laman</string>
	<string name="error_media_upload_connection">Ralat sambungan terjadi semasa memuat naik media</string>
	<string name="site_settings_disconnected_toast">Terputus, penyuntingan dinyahboleh.</string>
	<string name="site_settings_unsupported_version_error">Versi WordPress tidak disokong</string>
	<string name="site_settings_multiple_links_dialog_description">Memerlukan kelulusan untuk ulasan yang mengandungi lebih daripada jumlah pautan ini.</string>
	<string name="site_settings_close_after_dialog_switch_text">Tutup secara automatik</string>
	<string name="site_settings_close_after_dialog_description">Tutup ulasan secara automatik pada artikel.</string>
	<string name="site_settings_paging_dialog_description">Pecahkan jalur ulasan kepada berbilang halaman.</string>
	<string name="site_settings_paging_dialog_header">Ulasan setiap halaman</string>
	<string name="site_settings_close_after_dialog_title">Tutup pengulasan</string>
	<string name="site_settings_blacklist_description">Apabila ulasan mengandungi mana-mana perkataan berikut dalam kandungan, nama, URL, emel, atau IP, ia akan ditanda sebagai spam. Anda boleh mengisi sebahagian perkataan, oleh itu "press" akan padan dengan "WordPress."</string>
	<string name="site_settings_hold_for_moderation_description">Apabila ulasan mengandungi mana-mana perkataan ini dalam kandungan, nama, URL, emel atau IP, ia akan ditahan dibawah barisan penyederhanaan. Anda boleh mengisi sebahagian perkataan, oleh itu "press" akan padan dengan "WordPress."</string>
	<string name="site_settings_list_editor_input_hint">Masukkan perkataan atau frasa</string>
	<string name="site_settings_list_editor_no_items_text">Tiada butiran</string>
	<string name="site_settings_learn_more_caption">Anda boleh membatalkan tetapan ini bagi kiriman individu.</string>
	<string name="site_settings_rp_preview3_site">dalam "Naik Taraf"</string>
	<string name="site_settings_rp_preview3_title">Fokus Naiktaraf: VideoPress untuk Perkahwinan</string>
	<string name="site_settings_rp_preview2_site">dalam "Aplikasi"</string>
	<string name="site_settings_rp_preview2_title">Aplikasi WordPress untuk Android Mendapat Wajah Baharu</string>
	<string name="site_settings_rp_preview1_site">dalam "Mudah Alih"</string>
	<string name="site_settings_rp_preview1_title">Kemas Kini iPhone/iPad Besar Kini Didapati</string>
	<string name="site_settings_rp_show_images_title">Tunjuk Imej</string>
	<string name="site_settings_rp_show_header_title">Tunjukkan Pengepala</string>
	<string name="site_settings_rp_switch_summary">Kiriman Berkaitan memaparkan kandungan yang berkenaan daripada laman anda di bawah kiriman anda.</string>
	<string name="site_settings_rp_switch_title">Tunjukkan Kiriman Berkaitan</string>
	<string name="site_settings_delete_site_hint">Buang data laman anda dari aplikasi</string>
	<string name="site_settings_blacklist_hint">Ulasan yang sepadan dengan penapis ditanda sebagai spam</string>
	<string name="site_settings_moderation_hold_hint">Ulasan yang sepadan dengan penapis diletakkan dalam barisan penyederhanaan</string>
	<string name="site_settings_multiple_links_hint">Abaikan had pautan daripada pengguna dikenali</string>
	<string name="site_settings_whitelist_hint">Ulasan pengarang mesti mempunyai ulasan terdahulu yang diluluskan</string>
	<string name="site_settings_user_account_required_hint">Pengguna mestilah berdaftar dan log masuk untuk mengulas</string>
	<string name="site_settings_identity_required_hint">Penulis ulasan mesti mengisi nama dan emel</string>
	<string name="site_settings_manual_approval_hint">Ulasan mestilah diluluskan secara manual</string>
	<string name="site_settings_paging_hint">Papar ulsan dalam ketulan saiz yang ditetapkan</string>
	<string name="site_settings_threading_hint">Benarkan ulasan bersarang ke dalaman tertentu</string>
	<string name="site_settings_sort_by_hint">Menentukan aturan ulasan yang dipaparkan</string>
	<string name="site_settings_close_after_hint">Jangan benarkan ulasan selepas waktu yang ditetapkan</string>
	<string name="site_settings_receive_pingbacks_hint">Benarkan pemberitahuan pautan daripada blog-blog lain</string>
	<string name="site_settings_send_pingbacks_hint">Cuba beritahu mana-mana blog yang dipautkan daripada artikel</string>
	<string name="site_settings_allow_comments_hint">Benarkan pembaca mengirim ulasan</string>
	<string name="site_settings_discussion_hint">Lihat dan ubah tetapan perbincangan laman anda</string>
	<string name="site_settings_more_hint">Lihat semua tetapan Perbincangan yang ada</string>
	<string name="site_settings_related_posts_hint">Tunjukkan atau sembunyikan kiriman berkaitan dalam pembaca</string>
	<string name="site_settings_upload_and_link_image_hint">Bolehkan untuk selalu memuat naik imej saiz penuh</string>
	<string name="site_settings_image_width_hint">Saiz semula imej dalam kiriman ke lebar ini</string>
	<string name="site_settings_format_hint">Tetapkan format kiriman baharu</string>
	<string name="site_settings_category_hint">Tetapkan kategori kiriman baharu</string>
	<string name="site_settings_location_hint">Tambah data lokasi secara automatik ke kiriman anda</string>
	<string name="site_settings_password_hint">Tukar kata laluan anda</string>
	<string name="site_settings_username_hint">Akaun pengguna semasa</string>
	<string name="site_settings_language_hint">Bahasa utama blog ini ditulis dalam</string>
	<string name="site_settings_privacy_hint">Kawal siapa boleh melihat laman anda</string>
	<string name="site_settings_address_hint">Menukar alamat anda pada masa ini tidak disokong</string>
	<string name="site_settings_tagline_hint">Huraian pendek atau frasa menarik untuk menggambarkan blog anda</string>
	<string name="site_settings_title_hint">Dalam beberapa perkataan, jelaskan apa laman ini berkenaan dengan</string>
	<string name="site_settings_whitelist_known_summary">Ulasan daripada pengguna yang diketahui</string>
	<string name="site_settings_whitelist_all_summary">Ulasan daripada semua pengguna</string>
	<string name="site_settings_threading_summary">%d paras</string>
	<string name="site_settings_privacy_private_summary">Sulit</string>
	<string name="site_settings_privacy_hidden_summary">Tersembunyi</string>
	<string name="site_settings_privacy_public_summary">Umum</string>
	<string name="site_settings_delete_site_title">Hapuskan Laman</string>
	<string name="site_settings_blacklist_title">Senarai hitam</string>
	<string name="site_settings_moderation_hold_title">Tahan untuk Penyederhanaan</string>
	<string name="site_settings_multiple_links_title">Pautan dalam ulasan</string>
	<string name="site_settings_whitelist_title">Luluskan secara automatik</string>
	<string name="site_settings_threading_title">Penjaluran</string>
	<string name="site_settings_paging_title">Menomborkan Halaman</string>
	<string name="site_settings_sort_by_title">Isih berdasarkan</string>
	<string name="site_settings_account_required_title">Pengguna mesti dilog masuk</string>
	<string name="site_settings_identity_required_title">Mesti sertakan nama dan emel</string>
	<string name="site_settings_receive_pingbacks_title">Terima Ping Balik</string>
	<string name="site_settings_send_pingbacks_title">Hantar Ping Balik</string>
	<string name="site_settings_allow_comments_title">Benarkan Ulasan</string>
	<string name="site_settings_default_format_title">Format Lalai</string>
	<string name="site_settings_default_category_title">Kategori Lalai</string>
	<string name="site_settings_location_title">Bolehkan Lokasi</string>
	<string name="site_settings_address_title">Alamat</string>
	<string name="site_settings_title_title">Tajuk Laman</string>
	<string name="site_settings_tagline_title">Baris Slogan</string>
	<string name="site_settings_this_device_header">Peranti ini</string>
	<string name="site_settings_discussion_new_posts_header">Tetapan lalai bagi kiriman baharu</string>
	<string name="site_settings_account_header">Akaun</string>
	<string name="site_settings_writing_header">Menulis</string>
	<string name="newest_first">Terbaharu dahulu</string>
	<string name="site_settings_general_header">Am</string>
	<string name="discussion">Perbincangan</string>
	<string name="privacy">Privasi</string>
	<string name="related_posts">Kiriman Berkaitan</string>
	<string name="comments">Ulasan</string>
	<string name="close_after">Tutup selepas</string>
	<string name="oldest_first">Yang lama terdahulu</string>
	<string name="media_error_no_permission_upload">Anda tidak mempunyai kebenaran memuat naik media ke laman tersebut</string>
	<string name="unknown">Tidak diketahui</string>
	<string name="never">Tidak sama sekali</string>
	<string name="reader_err_get_post_not_found">Kiriman ini tidak lagi wujud</string>
	<string name="reader_err_get_post_not_authorized">Anda tidak dibenarkan melihat kiriman ini</string>
	<string name="reader_err_get_post_generic">Tidak boleh mendapatkan kiriman ini</string>
	<string name="blog_name_no_spaced_allowed">Alaman laman tidak boleh mengandungi ruang</string>
	<string name="invalid_username_no_spaces">Nama pengguna tidak mengandungi ruang</string>
	<string name="reader_empty_followed_blogs_no_recent_posts_description">Laman yang anda ikuti belum mengirim apa-apa baru-baru ini</string>
	<string name="reader_empty_followed_blogs_no_recent_posts_title">Tiada kiriman terkini</string>
	<string name="edit_media">Sunting media</string>
	<string name="media_details_copy_url_toast">URL disalin ke papan keratan</string>
	<string name="media_details_copy_url">Salin URL</string>
	<string name="media_details_label_date_uploaded">Dimuat naik</string>
	<string name="media_details_label_date_added">Ditambah</string>
	<string name="selected_theme">Tema Dipilih</string>
	<string name="could_not_load_theme">Tidak dapat memuat tema</string>
	<string name="theme_activation_error">Suatu kesilapan telah berlaku. Tidak dapat mengaktifkan tema.</string>
	<string name="theme_by_author_prompt_append"> oleh %1$s</string>
	<string name="theme_prompt">Terima kasih kerana memilih %1$s</string>
	<string name="theme_details">Perincian</string>
	<string name="theme_done">SELESAI</string>
	<string name="theme_manage_site">URUS LAMAN</string>
	<string name="theme_support">Sokongan</string>
	<string name="theme_try_and_customize">Cuba dan Suai Langgan</string>
	<string name="theme_view">Lihat</string>
	<string name="theme_activate">Aktifkan</string>
	<string name="title_activity_theme_support">Tema</string>
	<string name="active">Aktif</string>
	<string name="current_theme">Tema Semasa</string>
	<string name="customize">Suai Langgan</string>
	<string name="details">Perincian</string>
	<string name="date_range_end_date">Tarikh Akhir</string>
	<string name="support">Sokongan</string>
	<string name="date_range_start_date">Tarikh Mula</string>
	<string name="stats_referrers_spam_generic_error">Suatu kesilapan telah berlaku semasa operasi tersebut. Keadaan spam tidak diubah.</string>
	<string name="stats_referrers_marking_not_spam">Ditanda sebagai bukan spam</string>
	<string name="stats_referrers_marking_spam">Ditanda sebagai spam</string>
	<string name="stats_referrers_unspam">Bukan spam</string>
	<string name="theme_auth_error_authenticate">Gagal mengambil tema: pengesahan pengguna gagal</string>
	<string name="post_published">Kiriman diterbitkan</string>
	<string name="page_published">Halaman diterbitkan</string>
	<string name="post_updated">Kiriman dikemas kini</string>
	<string name="page_updated">Halaman dikemas kini</string>
	<string name="stats_referrers_spam">Spam</string>
	<string name="theme_no_search_result_found">Maaf, tiada tema ditemui</string>
	<string name="media_dimensions">Dimensi: %s</string>
	<string name="media_file_name">Nama fail: %s</string>
	<string name="media_uploaded_on">Muat naik pada: %s</string>
	<string name="media_file_type">Jenis fail: %s</string>
	<string name="upload_queued">Digilirkan</string>
	<string name="reader_label_gap_marker">Muatkan lebih banyak kiriman</string>
	<string name="notifications_no_search_results">Tiada laman sepadan dengan \'%s\'</string>
	<string name="search_sites">Cari laman</string>
	<string name="unread">Belum dibaca</string>
	<string name="notifications_empty_view_reader">Lihat Pembaca</string>
	<string name="notifications_empty_action_followers_likes">Dapatkan perhatian: ulasan pada kiriman yang anda telah baca.</string>
	<string name="notifications_empty_action_comments">Ikuti perbincangan: ulas pada kiriman dari blog yang anda ikuti.</string>
	<string name="notifications_empty_action_unread">Nyalakan semula perbualan: tulis kiriman baharu.</string>
	<string name="notifications_empty_action_all">Jadilah aktif! Ulasan pada kiriman dari blog yang anda ikuti.</string>
	<string name="notifications_empty_likes">Belum ada disukai untuk ditunjuk... lagi.</string>
	<string name="notifications_empty_followers">Belum ada pengikut untuk dilaporkan... lagi.</string>
	<string name="notifications_empty_comments">Belum ada ulasan baharu... lagi.</string>
	<string name="notifications_empty_unread">Anda telah lengkapkan semuanya!</string>
	<string name="stats_widget_error_jetpack_no_blogid">Sila capai Statistik dalam aplikasi, dan cuba tambah widget kemudian</string>
	<string name="stats_widget_error_readd_widget">Sila buang widget dan menambahnya semula</string>
	<string name="stats_widget_error_no_visible_blog">Statistik tidak dapat dicapai tanpa blog yang kelihatan</string>
	<string name="stats_widget_error_no_permissions">Akaun WordPress.com anda tidak dapat mencapai Statistik di blog ini</string>
	<string name="stats_widget_error_no_account">Sila log masuk ke dalam WordPress</string>
	<string name="stats_widget_error_generic">Statistik tidak dapat dimuatkan</string>
	<string name="stats_widget_loading_data">Memuat data...</string>
	<string name="stats_widget_name_for_blog">Statistik %1$s untuk hari ini</string>
	<string name="stats_widget_name">Statistik WordPress Hari Ini</string>
	<string name="add_location_permission_required">Kebenaran diperlukan untuk menambah lokasi</string>
	<string name="add_media_permission_required">Kebenaran diperlukan untuk menambah media</string>
	<string name="access_media_permission_required">Kebenaran diperlukan untuk mencapai media</string>
	<string name="stats_enable_rest_api_in_jetpack">Untuk melihat statistik anda, bolehkan modul API JSON dalam Jetpack.</string>
	<string name="error_open_list_from_notification">Kiriman atau halaman ini telah diterbitkan di laman lain</string>
	<string name="reader_short_comment_count_multi">%s Ulasan</string>
	<string name="reader_short_comment_count_one">1 Ulasan</string>
	<string name="reader_label_submit_comment">HANTAR</string>
	<string name="reader_hint_comment_on_post">Balas kiriman...</string>
	<string name="reader_discover_visit_blog">Lawat %s</string>
	<string name="reader_discover_attribution_blog">Asalnya dikirim pada %s</string>
	<string name="reader_discover_attribution_author">Asalnya dikirim oleh %s</string>
	<string name="reader_discover_attribution_author_and_blog">Asalnya dikirim oleh %1$s pada %2$s</string>
	<string name="reader_short_like_count_multi">%s Suka</string>
	<string name="reader_label_follow_count">%,d pengikut</string>
	<string name="reader_short_like_count_one">1 Suka</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">Kiriman Pembaca</string>
	<string name="local_draft_explainer">Kiriman ini adalah draf setempat yang belum diterbitkan</string>
	<string name="local_changes_explainer">Kiriman ini mempunyai penukaran setempat yang belum diterbitkan</string>
	<string name="notifications_push_summary">Tetapan bagi pemberitahuan yang muncul pada peranti anda.</string>
	<string name="notifications_email_summary">Tetapan bagi pemberitahuan yang dihantar ke emel yang dikaitkan ke akaun anda.</string>
	<string name="notifications_tab_summary">Tetapan bagi pemberitahuan yang muncul dalam tab Pemberitahuan.</string>
	<string name="notifications_disabled">Pemberitahuan aplikasi telah dilumpuhkan. Ketik di sini untuk membolehkannya dalam Tetapan.</string>
	<string name="notification_types">Jenis Pemberitahuan</string>
	<string name="error_loading_notifications">Tidak dapat memuat tetapan pemberitahuan</string>
	<string name="replies_to_your_comments">Balasan kepada ulasan anda</string>
	<string name="comment_likes">Ulasan disukai</string>
	<string name="app_notifications">Pemberitahuan aplikasi</string>
	<string name="email">Emel</string>
	<string name="notifications_tab">Tab pemberitahuan</string>
	<string name="notifications_comments_other_blogs">Ulasan di laman lain</string>
	<string name="notifications_wpcom_updates">Pengemas Kinian WordPress.com</string>
	<string name="notifications_other">Lain</string>
	<string name="notifications_account_emails">Emal dari WordPress.com</string>
	<string name="notifications_account_emails_summary">Kami akan selalu menghantar emel penting berkenaan akaun anda, tetapi anda juga boleh mendapat beberapa tambahan yang membantu.</string>
	<string name="notifications_sights_and_sounds">Pandangan dan Bunyian</string>
	<string name="your_sites">Laman Anda</string>
	<string name="stats_insights_latest_post_trend">Telah %1$s sejak %2$s diterbitkan. Sini adalah prestasi kiriman ini setakat ini…</string>
	<string name="stats_insights_latest_post_summary">Ringkasan Kiriman Terkini</string>
	<string name="button_revert">Berbalik</string>
	<string name="days_ago">%d hari yang lalu</string>
	<string name="yesterday">Semalam</string>
	<string name="connectionbar_no_connection">Tiada sambungan</string>
	<string name="button_back">Kembali</string>
	<string name="button_edit">Sunting</string>
	<string name="stats_no_activity_this_period">Tiada aktiviti tempoh ini</string>
	<string name="post_deleted">Kiriman dihapuskan</string>
	<string name="post_trashed">Kiriman dihantar ke sampah</string>
	<string name="trashed">Disampahkan</string>
	<string name="page_deleted">Halaman dihapuskan</string>
	<string name="button_stats">Statistik</string>
	<string name="button_trash">Sampah</string>
	<string name="button_preview">Pratonton</string>
	<string name="button_view">Lihat</string>
	<string name="button_publish">Terbit</string>
	<string name="page_trashed">Halaman dihantar ke sampah</string>
	<string name="my_site_no_sites_view_subtitle">Anda ingin menambah?</string>
	<string name="my_site_no_sites_view_title">Anda belum mempunyai mana-mana laman WordPress.</string>
	<string name="my_site_no_sites_view_drake">Ilustrasi</string>
	<string name="reader_toast_err_follow_blog_not_authorized">Anda tidak dibenarkan mencapai blog ini</string>
	<string name="reader_toast_err_follow_blog_not_found">Blog ini tidak dapat dijumpai</string>
	<string name="undo">Kembali ke asal</string>
	<string name="tabbar_accessibility_label_me">Saya</string>
	<string name="tabbar_accessibility_label_my_site">Laman Saya</string>
	<string name="editor_toast_changes_saved">Perubahan disimpan</string>
	<string name="passcodelock_prompt_message">Masukkan PIN anda</string>
	<string name="push_auth_expired">Permintaan telah tamat tempoh. Log masuk ke WordPress.com dan cuba semula.</string>
	<string name="stats_insights_most_popular_percent_views">%1$d%% yang dilihat</string>
	<string name="ignore">Abaikan</string>
	<string name="stats_insights_best_ever">Pandangan Terbaik Sampai Bila-Bila</string>
	<string name="stats_insights_most_popular_hour">Jam paling popular </string>
	<string name="stats_insights_most_popular_day">Hari paling popular</string>
	<string name="stats_insights_popular">Hari dan jam paling popular</string>
	<string name="stats_insights_today">Statistik Hari Ini</string>
	<string name="stats_insights_all_time">Kiriman, pandangan, dan pelawat sepanjang masa</string>
	<string name="stats_insights">Wawasan</string>
	<string name="stats_sign_in_jetpack_different_com_account">Untuk melihat statistik anda, log masuk ke akaun WordPress.com anda untuk menyambungkan JetPack.</string>
	<string name="stats_other_recent_stats_moved_label">Mencari statistik Terkini Yang Lain anda? Kami telah memindahnya ke halaman Wawasan.</string>
	<string name="me_disconnect_from_wordpress_com">Putuskan dari WordPress.com</string>
	<string name="me_connect_to_wordpress_com">Sambung ke WordPress.com</string>
	<string name="me_btn_login_logout">Log Masuk/Log Keluar</string>
	<string name="site_picker_cant_hide_current_site">"%s" tidak disembunyikan kerana ianya laman semasa</string>
	<string name="account_settings">Tetapan Akaun</string>
	<string name="me_btn_support">Bantuan &amp; Sokongan</string>
	<string name="site_picker_create_dotcom">Cipta laman WordPress.com</string>
	<string name="site_picker_add_self_hosted">Tambah laman yang dihos sendiri</string>
	<string name="site_picker_add_site">Tambah laman</string>
	<string name="site_picker_edit_visibility">Tunjuk/sembunyi laman</string>
	<string name="site_picker_title">Pilih laman</string>
	<string name="my_site_btn_view_admin">Lihat Pentadbir</string>
	<string name="my_site_btn_view_site">Lihat Laman</string>
	<string name="my_site_btn_switch_site">Tukar Laman</string>
	<string name="my_site_btn_blog_posts">Kiriman Blog</string>
	<string name="my_site_header_look_and_feel">Rupa dan Bentuk</string>
	<string name="my_site_header_publish">Terbit</string>
	<string name="my_site_btn_site_settings">Tetapan</string>
	<string name="my_site_header_configuration">Konfigurasi</string>
	<string name="reader_label_new_posts_subtitle">Tap untuk menunjukkannya</string>
	<string name="notifications_account_required">Log masuk ke WordPress.com untuk pemberitahuan</string>
	<string name="stats_unknown_author">Pengarang Tidak Diketahui</string>
	<string name="signout">Putuskan</string>
	<string name="image_added">Imej ditambah</string>
	<string name="deselect_all">Nyahpilih semua</string>
	<string name="sign_out_wpcom_confirm">Memutuskan akaun anda akan membuang semua data WordPress.com bagi @%s dari peranti ini, termasuklah draf setempat dan perubahan setempat.</string>
	<string name="hide">Sembunyi</string>
	<string name="show">Tunjuk</string>
	<string name="select_all">Pilih semua</string>
	<string name="select_from_new_picker">Pilihan jamak dengan pemetik baharu</string>
	<string name="no_media_sources">Tidak dapat mengambil media</string>
	<string name="error_loading_images">Ralat memuat imej</string>
	<string name="error_loading_videos">Ralat memuat video</string>
	<string name="loading_blog_images">Mengambil imej</string>
	<string name="loading_blog_videos">Mengambil video</string>
	<string name="no_blog_images">Tiada imej</string>
	<string name="no_device_images">Tiada imej</string>
	<string name="stats_generic_error">Statistik Yang Diperlukan tidak dapat dimuatkan</string>
	<string name="no_device_videos">Tiada video</string>
	<string name="no_blog_videos">Tiada video</string>
	<string name="error_loading_blog_images">Tidak dapat mengambil imej</string>
	<string name="error_loading_blog_videos">Tidak dapat mengambil video</string>
	<string name="loading_images">Memuat imej</string>
	<string name="loading_videos">Memuat video</string>
	<string name="no_media">Tiada media</string>
	<string name="add_to_post">Tambah ke Kiriman</string>
	<string name="error_publish_no_network">Tidak boleh menerbit semasa tiada sambungan. Disimpan sebagai draf.</string>
	<string name="two_step_sms_sent">Periksa mesej teks anda untuk kod pengesahan.</string>
	<string name="device">Peranti</string>
	<string name="tab_title_device_images">Imej Peranti</string>
	<string name="tab_title_device_videos">Video Peranti</string>
	<string name="two_step_footer_label">Masukkan kod dari aplikasi pengesah anda.</string>
	<string name="media_details_label_file_name">Nama fail</string>
	<string name="media_details_label_file_type">Jenis fail</string>
	<string name="editor_toast_invalid_path">Laluan fail tidak sah</string>
	<string name="invalid_verification_code">Kod pengesahan tidak sah</string>
	<string name="language">Bahasa</string>
	<string name="tab_title_site_videos">Video Laman</string>
	<string name="verification_code">Kod pengesahan</string>
	<string name="verify">Sahkan</string>
	<string name="two_step_footer_button">Hantar kod melalui mesej teks</string>
	<string name="sign_in_jetpack">Log masuk ke akaun WordPress.com anda dan berhubung dengan Jetpack.</string>
	<string name="auth_required">Log masuk semula untuk meneruskan.</string>
	<string name="media_picker_title">Pilih media</string>
	<string name="take_photo">Ambil gambar</string>
	<string name="take_video">Ambil video</string>
	<string name="tab_title_site_images">Imej Laman</string>
	<string name="stats_view_authors">Pengarang</string>
	<string name="error_notification_open">Tidak dapat membuka pemberitahuan</string>
	<string name="comments_fetching">Mengambil ulasan...</string>
	<string name="media_fetching">Mengambil media...</string>
	<string name="pages_fetching">Mengambil halaman...</string>
	<string name="posts_fetching">Mengambil kiriman...</string>
	<string name="stats_empty_search_terms_desc">Pelajari dengan lanjut mengenai trafik carian anda dengan melihat pada istilah yang dicari oleh para pelawat anda untuk mencari laman anda.</string>
	<string name="reader_empty_posts_request_failed">Tidak dapat mendapatkan kiriman</string>
	<string name="publisher">Penerbit:</string>
	<string name="stats_followers_total_email_paged">Menunjukkan %1$d - %2$d daripada %3$s Pengikut Emel</string>
	<string name="stats_search_terms_unknown_search_terms">Istilah Carian Tidak Diketahui</string>
	<string name="stats_followers_total_wpcom_paged">Menunjukkan %1$d - %2$d daripada %3$s Pengikut WordPress.com</string>
	<string name="stats_empty_search_terms">Tiada istilah carian direkodkan</string>
	<string name="stats_entry_search_terms">Istilah Carian</string>
	<string name="stats_view_search_terms">Istilah Carian</string>
	<string name="toast_err_post_uploading">Tidak dapat membuka kiriman semasa ianya dimuat naik</string>
	<string name="error_copy_to_clipboard">Ralat berlaku semasa menyalin teks ke papan keratan</string>
	<string name="logs_copied_to_clipboard">Log aplikasi telah disalin ke papan keratan</string>
	<string name="stats_average_per_day">Purata Sehari</string>
	<string name="stats_months_and_years">Bulan dan Tahun</string>
	<string name="reader_label_new_posts">Kiriman baharu</string>
	<string name="post_uploading">Memuat naik</string>
	<string name="stats_total">Jumlah</string>
	<string name="stats_overall">Keseluruhan</string>
	<string name="stats_period">Tempoh</string>
	<string name="reader_empty_posts_in_blog">Blog ini kosong</string>
	<string name="stats_recent_weeks">Minggu-Minggu Terkini</string>
	<string name="reader_page_recommended_blogs">Laman yang anda mungkin suka</string>
	<string name="stats_followers_days">%1$d hari</string>
	<string name="stats_followers_hours">%1$d jam</string>
	<string name="stats_followers_minutes">%1$d minit</string>
	<string name="stats_followers_months">%1$d bulan</string>
	<string name="stats_followers_years">%1$d tahun</string>
	<string name="stats_followers_a_day">Sehari</string>
	<string name="stats_followers_a_minute_ago">seminit yang lalu</string>
	<string name="stats_followers_a_month">Sebulan</string>
	<string name="stats_followers_a_year">Setahun</string>
	<string name="stats_followers_an_hour_ago">sejam lalu</string>
	<string name="stats_entry_top_commenter">Pengarang</string>
	<string name="stats_comments_by_authors">Oleh Pengarang</string>
	<string name="stats_comments_by_posts_and_pages">Berdasarkan Kiriman &amp; Halaman</string>
	<string name="stats_view_countries">Negara</string>
	<string name="stats_empty_top_posts_desc">Temui kandungan anda yang paling dilihat, dan periksa prestasi kiriman dan halaman dari semasa ke semasa.</string>
	<string name="stats_followers_email_selector">Emel</string>
	<string name="stats_empty_geoviews_desc">Jelajahi senarai untuk melihat negara dan kawasan mana menjana trafik terbanyak ke laman anda.</string>
	<string name="themes_fetching">Mengambil tema...</string>
	<string name="stats_entry_followers">Pengikut</string>
	<string name="stats_totals_publicize">Pengikut</string>
	<string name="stats_view_followers">Pengikut</string>
	<string name="stats_empty_tags_and_categories_desc">Dapatkan gambaran keseluruhan topik-topik yang paling popular di laman anda, seperti yang dipantulkan dalam kiriman teratas anda dari minggu lepas.</string>
	<string name="stats_empty_comments_desc">Jika anda membenarkan ulasan di laman anda, jejak pengulas teratas anda dan termui kandungan apa yang mencetuskan perbincangan yang paling meriah, berdasarkan pada 1,000 ulasan yang terkini.</string>
	<string name="stats_empty_video_desc">Jika anda telah memuat naik video menggunakan VidePress, ketahui berapa kali ianya ditonton.</string>
	<string name="stats_empty_publicize_desc">Jejaki pengikut anda daripada pelbagai perkhidmatan perhubungan sosial menggunakan publisiti.</string>
	<string name="stats_empty_followers_desc">Jejaki bilangan pengikut keseluruhan anda, dan berapa lama setiap orang telah mengikuti laman anda.</string>
	<string name="stats_empty_referrers_desc">Pelajari dengan lanjut mengenai keterlihatan laman anda dengan melihat pada laman web dan enjin carian yang menghantar trafik tertinggi ke hala anda</string>
	<string name="stats_likes">Disukai</string>
	<string name="stats_entry_clicks_link">Pautan</string>
	<string name="stats_empty_clicks_title">Tiada kllik direkodkan</string>
	<string name="stats_empty_geoviews">Tiada negara direkodkan</string>
	<string name="stats_empty_followers">Tiada pengikut</string>
	<string name="stats_timeframe_years">Tahun</string>
	<string name="stats_views">Pandangan</string>
	<string name="stats_visitors">Pelawat</string>
	<string name="stats_comments_total_comments_followers">Jumlah kiriman dengan pengikut ulasan: %1$s</string>
	<string name="stats_empty_publicize">Tiada pengikut publisiti direkodkan</string>
	<string name="stats_empty_video">Tiada video dimainkan</string>
	<string name="stats_empty_top_authors_desc">Jejak pandangan pada setiap kiriman penyumbang, dan zum masuk untuk menemui kandungan paling popular mengikut setiap pengarang.</string>
	<string name="stats_empty_tags_and_categories">Tiada kiriman atau halaman ditag yang dilihat</string>
	<string name="stats_view_videos">Video</string>
	<string name="stats_view_publicize">Publisiti</string>
	<string name="stats_pagination_label">Halaman %1$s daripada %2$s</string>
	<string name="stats_totals_followers">Sejak</string>
	<string name="stats_entry_video_plays">Video</string>
	<string name="stats_entry_publicize">Perkhidmatan</string>
	<string name="stats_view_top_posts_and_pages">Kiriman &amp; Halaman</string>
	<string name="stats_empty_clicks_desc">Bila kandungan anda termasuk pautan ke laman lain, anda akan dapat melihat mana satu yang paling diklik oleh pelawat anda.</string>
	<string name="stats_empty_referrers_title">Tiada perujuk direkodkan</string>
	<string name="stats_empty_top_posts_title">Tiada kiriman atau halaman dilihat</string>
	<string name="stats_for">Statistik bagi %s</string>
	<string name="stats_other_recent_stats_label">Lain Statistik Terkini</string>
	<string name="stats_view_all">Lihat semua</string>
	<string name="stats_view">Lihat</string>
	<string name="stats_followers_seconds_ago">beberapa saat lalu</string>
	<string name="stats_followers_total_email">Jumlah Pengikut Emel: %1$s</string>
	<string name="stats_followers_wpcom_selector">WordPress.com</string>
	<string name="stats_followers_total_wpcom">Jumlah Pengikut WordPress.com: %1$s</string>
	<string name="ssl_certificate_details">Perincian</string>
	<string name="cab_selected">%d dipilih</string>
	<string name="confirm_delete_media">Hapuskan butir yang dipilih?</string>
	<string name="confirm_delete_multi_media">Hapuskan butiran yang dipilih?</string>
	<string name="delete_sure">Hapuskan draf ini</string>
	<string name="delete_sure_page">Hapuskan halaman ini</string>
	<string name="delete_sure_post">Hapuskan kiriman ini</string>
	<string name="media_gallery_date_range">Paparkan media dari %1$s ke %2$s</string>
	<string name="sure_to_remove_account">Buang laman ini?</string>
	<string name="reader_label_comment_count_multi">%,d ulasan</string>
	<string name="reader_title_photo_viewer">%1$d dari %2$d</string>
	<string name="browse_our_faq_button">Layar Soalan Lazim kami</string>
	<string name="agree_terms_of_service">Dengan mencipta akaun anda bersetuju dengan %1$sTerma Perkhidmatan%2$s yang mempesonakan</string>
	<string name="error_publish_empty_post">Tidak boleh menerbitkan kiriman kosong</string>
	<string name="comment">Ulasan</string>
	<string name="comment_trashed">Ulasan disampahkan</string>
	<string name="reader_label_comments_closed">Ulasan ditutup</string>
	<string name="reader_label_comments_on">Ulasan dihidupkan</string>
	<string name="create_new_blog_wpcom">Cipta blog WordPress.com</string>
	<string name="faq_button">Soalan Lazim</string>
	<string name="reader_label_like">Suka</string>
	<string name="mnu_comment_liked">Disukai</string>
	<string name="reader_empty_comments">Belum ada ulasan</string>
	<string name="media_empty_list_custom_date">Tiada media dalam jangka masa ini</string>
	<string name="more">Selanjutnya</string>
	<string name="older_two_days">Lebih dari 2 hari</string>
	<string name="older_last_week">Lebih dari seminggu</string>
	<string name="stats_no_blog">Statistik tidak dapat dimuatkan bagi blog yang diperlukan</string>
	<string name="select_a_blog">Pilih laman WordPress</string>
	<string name="sending_content">Memuat naik %s kandungan</string>
	<string name="uploading_total">Memuat naik %1$d daripada %2$d</string>
	<string name="posts_empty_list">Belum ada kiriman. Kenapa tidak wujudkannya?</string>
	<string name="comment_reply_to_user">Balasan kepada %s</string>
	<string name="pages_empty_list">Belum ada halaman. Kenapa tidak wujudkannya?</string>
	<string name="posting_post">Mengirim "%s"</string>
	<string name="signing_out">Melog keluar…</string>
	<string name="reader_empty_followed_blogs_title">Anda belum mengikuti mana-mana laman</string>
	<string name="reader_empty_posts_liked">Anda belum menyukai mana-mana kiriman</string>
	<string name="nux_help_description">Lawat pusat bantuan untuk mendapatkan jawapan kepada soalan lazim atau lawat forum untuk bertanyakan soalan baharu</string>
	<string name="new_blog_wpcom_created">Blog WordPress.com diwujudkan!</string>
	<string name="reader_empty_posts_in_tag">Tiada kiriman dengan tag ini</string>
	<string name="reader_label_view_original">Lihat artikel asal</string>
	<string name="reader_label_comment_count_single">Satu ulasan</string>
	<string name="error_refresh_unauthorized_pages">Anda tidak mempunyai kebenaran melihat atau menyunting halaman</string>
	<string name="error_refresh_unauthorized_comments">Anda tidak mempunyai kebenaran melihat atau menyunting ulasan</string>
	<string name="older_month">Lebih dari sebulan</string>
	<string name="error_refresh_unauthorized_posts">Anda tidak mempunyai kebenaran melihat atau menyunting kiriman</string>
	<string name="reader_toast_err_generic">Tidak dapat melaksanakan tindakan ini</string>
	<string name="reader_toast_err_block_blog">Tidak dapat menyekat blog ini</string>
	<string name="reader_toast_blog_blocked">Kiriman daripada blog ini tidak akan ditunjukkan</string>
	<string name="reader_menu_block_blog">Sekat blog ini</string>
	<string name="contact_us">Hubungi kami</string>
	<string name="hs__new_conversation_header">Bualan sokongan</string>
	<string name="hs__conversation_header">Bualan sokongan</string>
	<string name="hs__username_blank_error">Masukkan nama yang sah</string>
	<string name="hs__invalid_email_error">Masukkan alamat emel yang sah</string>
	<string name="hs__conversation_detail_error">Terangkan masalah yang kelihatan</string>
	<string name="add_location">Tambah lokasi</string>
	<string name="current_location">Lokasi semasa</string>
	<string name="search_location">Cari</string>
	<string name="search_current_location">Kesan</string>
	<string name="edit_location">Sunting</string>
	<string name="preference_send_usage_stats">Hantar statistik</string>
	<string name="preference_send_usage_stats_summary">Hantar statistik penggunaan secara automatik untuk membantu kami menambahbaik WordPress untuk Android</string>
	<string name="update_verb">Kemas kini</string>
	<string name="schedule_verb">Jadual</string>
	<string name="reader_title_subs">Tag &amp;amp; Blog</string>
	<string name="reader_page_followed_tags">Tag yang diikuti</string>
	<string name="reader_hint_add_tag_or_url">Masukkan tag atau URL untuk diikuti</string>
	<string name="reader_label_followed_blog">Blog diikuti</string>
	<string name="reader_label_tag_preview">Kiriman dengan tag %s</string>
	<string name="reader_toast_err_get_blog_info">Tidak dapat memaparkan blog ini</string>
	<string name="reader_toast_err_already_follow_blog">Anda sudah mengikuti blog ini</string>
	<string name="reader_toast_err_follow_blog">Tidak dapat mengikut blog ini</string>
	<string name="reader_toast_err_unfollow_blog">Tidak dapat untuk tidak mengikut blog ini</string>
	<string name="reader_empty_recommended_blogs">Tiada blog yang disyorkan</string>
	<string name="reader_page_followed_blogs">Laman yang diikuti</string>
	<string name="reader_title_blog_preview">Blog Pembaca</string>
	<string name="reader_title_tag_preview">Tag Pembaca</string>
	<string name="media_empty_list">Tiada media</string>
	<string name="ptr_tip_message">Tip: Tarik ke bawah untuk segar semula</string>
	<string name="saving">Simpan...</string>
	<string name="help">Bantuan</string>
	<string name="forums">Forum</string>
	<string name="help_center">Pusat bantuan</string>
	<string name="ssl_certificate_error">Sijil SSL tidak sah</string>
	<string name="ssl_certificate_ask_trust">Jika anda biasanya berhubung ke laman ini tanpa masalah, ralat ini mungkin bermakna bahawa seseorang sedang cuba menyamar sebagai laman ini, dan anda tidak sepatutnya teruskan. Adakah anda masih ingin mempercayai sijil ini?</string>
	<string name="forgot_password">Hilang kata laluan anda?</string>
	<string name="out_of_memory">Memori peranti tidak mencukupi</string>
	<string name="adding_cat_success">Kategori berjaya ditambah</string>
	<string name="cat_name_required">Medan nama kategori dikehendaki</string>
	<string name="category_automatically_renamed">Nama kategori %1$s tidak sah. Ia telah dinamakan semula sebagai %2$s.</string>
	<string name="no_account">Akaun WordPress tidak dijumpai, tambah akaun dan cuba lagi</string>
	<string name="stats_bar_graph_empty">Tiada statistik tersedia</string>
	<string name="reply_failed">Balasan gagal</string>
	<string name="notifications_empty_list">Tiada notifikasi</string>
	<string name="error_delete_post">Ralat berlaku apabila sedang menghapuskan %s</string>
	<string name="error_refresh_posts">Kiriman tidak dapat disegar semula pada masa ini</string>
	<string name="error_refresh_pages">Laman tidak dapat disegar semula pada masa ini</string>
	<string name="error_refresh_notifications">Pemberitahuan tidak dapat disegar semula pada masa ini</string>
	<string name="error_refresh_stats">Statistik tidak dapat disegar semula pada masa ini</string>
	<string name="error_generic">Ralat berlaku</string>
	<string name="error_moderate_comment">Ralat berlaku semasa penyederhanaan</string>
	<string name="error_edit_comment">Ralat berlaku semasa mengedit komen</string>
	<string name="error_upload">Ralat berlaku semasa memuat naik %s</string>
	<string name="error_load_comment">Tidak dapat memuatkan komen</string>
	<string name="error_downloading_image">Ralat memuat turun imej</string>
	<string name="passcode_wrong_passcode">PIN Salah</string>
	<string name="username_exists">Nama pengguna tersebut sudah wujud</string>
	<string name="email_exists">Alamat emel tersebut sudah digunakan</string>
	<string name="blog_name_required">Masukkan alamat laman</string>
	<string name="blog_name_not_allowed">Alamat laman tersebut tidak dibenarkan</string>
	<string name="blog_name_must_be_at_least_four_characters">Alamat laman mestilah sekurang-kurangnya 4 karakter</string>
	<string name="blog_name_must_be_less_than_sixty_four_characters">Alamat laman mestilah kurang daripada 64 karakter</string>
	<string name="blog_name_contains_invalid_characters">Alamat laman tidak boleh mengandungi karakter "_"</string>
	<string name="blog_name_cant_be_used">Anda tidak boleh menggunakan alaman laman tersebut</string>
	<string name="blog_name_only_lowercase_letters_and_numbers">Alamat laman hanya boleh mengandungi huruf kecil (a-z) dan nombor</string>
	<string name="blog_name_exists">Laman tersebut sudah wujud</string>
	<string name="blog_name_reserved">Laman tersebut adalah tersimpan</string>
	<string name="username_reserved_but_may_be_available">Nama pengguna tersebut adalah tersimpan tetapi mungkin akan tersedia dalam beberapa hari</string>
	<string name="blog_name_reserved_but_may_be_available">Laman tersebut adalah tersimpan tetapi mungkin akan tersedia dalam beberapa hari</string>
	<string name="username_or_password_incorrect">Nama pengguna atau kata laluan yang anda masukkan adalah tidak betul</string>
	<string name="nux_cannot_log_in">Kami tidak dapat melog anda masuk</string>
	<string name="invalid_password_message">Kata laluan mestilah mengandungi sekurang-kurangnya 4 karakter</string>
	<string name="invalid_username_too_short">Nama pengguna mestilah lebih daripada 4 karakter</string>
	<string name="invalid_username_too_long">Nama pengguna mestilah kurang daripada 61 karakter</string>
	<string name="username_only_lowercase_letters_and_numbers">Nama pengguna hanya boleh mengandungi huruf kecil (a-z) dan nombor</string>
	<string name="username_required">Masukkan nama pengguna</string>
	<string name="username_not_allowed">Nama pengguna tidak dibenarkan</string>
	<string name="username_must_be_at_least_four_characters">Nama pengguna mestilah sekurang-kurangnya 4 karakter</string>
	<string name="username_contains_invalid_characters">Nama pengguna tidak boleh mengandungi karakter “_”</string>
	<string name="username_must_include_letters">Nama pengguna mesti mengandungi sekurang-kurangnya 1 huruf (a-z)</string>
	<string name="email_invalid">Masukkan alamat emel yang sah</string>
	<string name="email_not_allowed">Alamat emel tersebut tidak dibenarkan</string>
	<string name="no_network_message">Tiada rangkaian tersedia</string>
	<string name="could_not_remove_account">Tidak dapat membuang blog</string>
	<string name="gallery_error">Butir media tidak boleh didapatkan kembali</string>
	<string name="blog_not_found">Ralat berlaku apabila mencapai blog ini</string>
	<string name="wait_until_upload_completes">Tunggu sehingga muat naik selesai</string>
	<string name="theme_fetch_failed">Gagal mengambil tema</string>
	<string name="theme_set_failed">Gagal menetapkan tema</string>
	<string name="theme_auth_error_message">Pastikan anda mempunyai hak untuk menetapkan tema</string>
	<string name="mnu_comment_unspam">Bukan spam</string>
	<string name="no_site_error">Tidak dapat menyambung ke laman WordPress</string>
	<string name="adding_cat_failed">Tambah kategori telah gagal</string>
	<string name="sdcard_message">Kad SD yang dipasang diperlukan untuk memuat naik media</string>
	<string name="error_refresh_comments">Ulasan tidak dapat disegar semula pada masa ini</string>
	<string name="comments_empty_list">Tiada ulasan</string>
	<string name="stats_empty_comments">Belum ada ulasan</string>
	<string name="invalid_url_message">Periksa sama ada URL yang dimasukkan adalah sah</string>
	<string name="invalid_email_message">Alamat emel anda tidak sah</string>
	<string name="media_gallery_num_columns">Bilangan lajur</string>
	<string name="media_gallery_type_thumbnail_grid">Grid gambar kenit</string>
	<string name="cannot_delete_multi_media_items">Sesetengah media tidak boleh dihapuskan pada masa ini. Cuba sebentar lagi.</string>
	<string name="themes_live_preview">Pratonton secara langsung</string>
	<string name="theme_current_theme">Tema semasa</string>
	<string name="theme_premium_theme">Tema premium</string>
	<string name="link_enter_url_text">Teks pautan (pilihan)</string>
	<string name="create_a_link">Cipta pautan</string>
	<string name="local_draft">Draf setempat</string>
	<string name="xmlrpc_error">Tidak dapat dihubungi. Masukkan laluan penuh ke xmlrpc.php di laman anda dan cuba lagi.</string>
	<string name="select_categories">Pilih kategori</string>
	<string name="add_comment">Tambah komen</string>
	<string name="connection_error">Ralat hubungan</string>
	<string name="cancel_edit">Batal edit</string>
	<string name="scaled_image_error">Masukkan nilai lebar berskala yang sah</string>
	<string name="post_not_found">Ralat berlaku apabila kiriman dimuatkan. Segar semula kiriman anda dan cuba lagi.</string>
	<string name="mnu_comment_trash">Sampah</string>
	<string name="dlg_approving_comments">Meluluskan</string>
	<string name="dlg_unapproving_comments">Tidak meluluskan</string>
	<string name="dlg_trashing_comments">Hantar ke sampah</string>
	<string name="dlg_confirm_trash_comments">Hantar ke sampah?</string>
	<string name="trash_yes">Sampah</string>
	<string name="trash">Sampah</string>
	<string name="author_name">Nama pengarang</string>
	<string name="author_email">Emel pengarang</string>
	<string name="author_url">URL pengarang</string>
	<string name="saving_changes">Simpan perubahan</string>
	<string name="upload_failed">Muat naik gagal</string>
	<string name="horizontal_alignment">Jajaran melintang</string>
	<string name="file_not_found">Fail media untuk dimuat naik tidak dapat dicari. Adakah ia dihapuskan atau dipindahkan></string>
	<string name="delete_post">Hapus kiriman</string>
	<string name="delete_page">Hapus laman</string>
	<string name="comment_status_approved">Diluluskan</string>
	<string name="comment_status_unapproved">Menunggu</string>
	<string name="comment_status_spam">Spam</string>
	<string name="comment_status_trash">Disampahkan</string>
	<string name="mnu_comment_approve">Lulus</string>
	<string name="mnu_comment_unapprove">Tidak diluluskan</string>
	<string name="mnu_comment_spam">Spam</string>
	<string name="category_slug">Slug kategori (pilihan)</string>
	<string name="category_desc">Keterangan kategori (pilihan)</string>
	<string name="category_parent">Induk kategori (pilihan):</string>
	<string name="share_action_post">Kiriman baharu</string>
	<string name="file_error_create">Tidak dapat mencipta fail sementara untuk muat naik media. Pastikan terdapat ruang yang cukup dalam peranti anda.</string>
	<string name="location_not_found">Lokasi tidak diketahui</string>
	<string name="open_source_licenses">Lesen sumber terbuka</string>
	<string name="delete_draft">Hapus draf</string>
	<string name="preview_page">Pratonton laman</string>
	<string name="preview_post">Pratonton kiriman</string>
	<string name="post_not_published">Status kiriman tidak diterbitkan</string>
	<string name="page_not_published">Status laman tidak diterbitkan</string>
	<string name="view_in_browser">Lihat di pelayar</string>
	<string name="add_new_category">Tambah kategori baharu</string>
	<string name="category_name">Nama kategori</string>
	<string name="privacy_policy">Polisi privasi</string>
	<string name="local_changes">Perubahan setempat</string>
	<string name="add_account_blog_url">Alamat blog</string>
	<string name="wordpress_blog">Blog WordPress</string>
	<string name="fatal_db_error">Ralat berlaku semasa mencipta pangkalan data aplikasi. Cuba memasangnya semula.</string>
	<string name="jetpack_message_not_admin">Pemalan Jetpack diperlukan bagi statistik. Hubungi pentadbir laman.</string>
	<string name="reader_title_applog">Log aplikasi</string>
	<string name="reader_share_link">Kongsi pautan</string>
	<string name="reader_toast_err_add_tag">Tidak dapat menambah tag ini</string>
	<string name="reader_toast_err_remove_tag">Tidak dapat membuang tag ini</string>
	<string name="pending_review">Menunggu semak semula</string>
	<string name="http_credentials">Kelayakan HTTP (pilihan)</string>
	<string name="http_authorization_required">Kebenaran diperlukan</string>
	<string name="post_format">Format kiriman</string>
	<string name="new_post">Kiriman baharu</string>
	<string name="new_media">Media baharu</string>
	<string name="view_site">Lihat laman</string>
	<string name="required_field">Medan yang diperlukan</string>
	<string name="email_hint">Alamat emel</string>
	<string name="site_address">Alamat laman anda yang dihos sendiri (URL)</string>
	<string name="email_cant_be_used_to_signup">Anda tidak boleh menggunakan alamat emel tersebut untuk mendaftar. Kami menghadapi masalah dimana emel kami dihalang oleh perkhidmatan tersebut. Gunakan penyedia emel yang lain. </string>
	<string name="email_reserved">Alamat emel tersebut telahpun digunakan. Periksa kota masuk anda untuk emel pengaktifan. Jika anda tidak mengaktifkannya anda boleh mencuba lagi dalam beberapa hari.</string>
	<string name="blog_name_must_include_letters">Alamat laman mestilah mempunyai sekurang-kurangnya 1 abjad (a-z)</string>
	<string name="blog_name_invalid">Alamat laman tidak sah</string>
	<string name="blog_title_invalid">Tajuk laman tidak sah</string>
	<string name="image_settings">Tetapan imej</string>
	<string name="error_blog_hidden">Blog ini disembunyi dan tidak dapat dimuatkan. Bolehkan ia semula dalam tetapan dan cuba lagi.</string>
	<string name="page_settings">Tetapan laman</string>
	<string name="media_gallery_settings_title">Tetapan galeri</string>
	<string name="post_settings">Tetapan kiriman</string>
	<string name="remove_account">Buang laman</string>
	<string name="blog_removed_successfully">Laman berjaya dibuang</string>
	<string name="account_details">Perincian akaun</string>
	<string name="sure_to_cancel_edit_comment">Batal menyunting komen ini?</string>
	<string name="hint_comment_content">Ulasan</string>
	<string name="comment_added">Ulasan berjaya ditambah</string>
	<string name="toast_comment_unedited">Ulasan tidak berubah</string>
	<string name="content_required">Ulasan diwajibkan</string>
	<string name="trash_no">Jangan sampahkan</string>
	<string name="edit_comment">Sunting ulasan</string>
	<string name="media_gallery_edit">Sunting galeri</string>
	<string name="edit_post">Sunting kiriman</string>
	<string name="media_gallery_image_order">Aturan imej</string>
	<string name="learn_more">Pelajari selanjutnya</string>
	<string name="dlg_spamming_comments">Ditanda sebagai spam</string>
	<string name="share_action_media">Pustaka media</string>
	<string name="invalid_site_url_message">Periksa bahawa URL laman yang dimasukkan adalah sah</string>
	<string name="notifications_empty_all">Belum ada pemberitahuan.</string>
	<string name="media_error_no_permission">Anda tidak mempunyai kebenaran untuk melihat pustaka media</string>
	<string name="deleting_post">Menghapuskan kiriman</string>
	<string name="share_url_post">Kongsi kiriman</string>
	<string name="share_url_page">Kongsi laman</string>
	<string name="share_link">Kongsi pautan</string>
	<string name="deleting_page">Menghapuskan halaman</string>
	<string name="creating_your_site">Cipta laman anda</string>
	<string name="creating_your_account">Mencipta akaun anda</string>
	<string name="error_refresh_media">Sesuatu tidak kena semasa menyegar semula perpustakaan media. Cuba sebentar lagi.</string>
	<string name="reader_empty_posts_in_tag_updating">Mengambil kiriman...</string>
	<string name="reader_likes_you_and_multi">Anda dan %,d yang lain sukakannya</string>
	<string name="reader_likes_multi">%,d orang sukakanya</string>
	<string name="reader_toast_err_get_comment">Komen ini tidak boleh didapatkan</string>
	<string name="reader_label_reply">Balas</string>
	<string name="video">Video</string>
	<string name="download">Memuat turun media</string>
	<string name="cant_share_no_visible_blog">Anda tidak boleh berkongsi ke WordPress tanpa blog yang kelihatan</string>
	<string name="comment_spammed">Ulasan ditanda sebagai spam</string>
	<string name="select_time">Pilih masa</string>
	<string name="reader_likes_you_and_one">Anda dan seorang lagi sukakannya</string>
	<string name="select_date">Pilih tarikh</string>
	<string name="pick_photo">Pilih gambar</string>
	<string name="pick_video">Pilih video</string>
	<string name="reader_toast_err_get_post">Tidak boleh mendapatkan kiriman ini</string>
	<string name="validating_user_data">Pengesahan data pengguna</string>
	<string name="validating_site_data">Pengesahan data laman</string>
	<string name="account_two_step_auth_enabled">Pengesahan dua langkah telah dibolehkan untuk akaun ini. Lawat tetapan keselamatan anda di WordPress.com dan janakan kata laluan bagi aplikasi tersebut.</string>
	<string name="reader_empty_followed_blogs_description">Tapi jangan khuatir, hanya ketik ikon di atas sebelah kanan untuk memulakan pengembaraan!</string>
	<string name="nux_add_selfhosted_blog">Tambah laman yang dihos sendiri</string>
	<string name="nux_oops_not_selfhosted_blog">Daftar masuk ke WordPress.com</string>
	<string name="password_invalid">Anda perlukan kata laluan yang lebih selamat. Pastikan anda menggunakan 7 atau lebih aksara, campuran abjad kecil dan besar, nombor atau aksara khas.</string>
	<string name="nux_tap_continue">Teruskan</string>
	<string name="nux_welcome_create_account">Cipta akaun</string>
	<string name="signing_in">Melog masuk...</string>
	<string name="media_add_new_media_gallery">Cipta galeri</string>
	<string name="empty_list_default">Senarai ini kosong</string>
	<string name="select_from_media_library">Pilih dari perpustakaan media</string>
	<string name="jetpack_message">Pemalam Jetpack diperlukan bagi statistik. Anda ingin memasang Jetpack?</string>
	<string name="jetpack_not_found">Pemalam Jetpack tidak dijumpai</string>
	<string name="reader_untitled_post">(Tanpa tajuk)</string>
	<string name="reader_share_subject">Dikongsi dari %s</string>
	<string name="reader_btn_share">Kongsi</string>
	<string name="reader_btn_follow">Ikut</string>
	<string name="reader_toast_err_url_intent">Tidak dapat membuka %s</string>
	<string name="connecting_wpcom">Berhubung ke WordPress.com</string>
	<string name="username_invalid">Nama pengguna tidak sah</string>
	<string name="limit_reached">Had telah dicapai. Anda boleh mencuba lagi dalam masa seminit. Cubaan sebelum tempoh tersebut hanya akan meningkatkan masa menunggu anda sebelum larangan dibatalkan. Jika anda  fikirkan ianya suatu kesilapan, hubungi sokongan.</string>
	<string name="nux_tutorial_get_started_title">Mulakan!</string>
	<string name="reader_btn_unfollow">Mengikuti</string>
	<string name="reader_label_added_tag">%s ditambah</string>
	<string name="reader_label_removed_tag">%s dibuang</string>
	<string name="reader_likes_one">Seorang menyukainya</string>
	<string name="reader_likes_only_you">Anda menyukainya</string>
	<string name="reader_toast_err_comment_failed">Tidak dapat mengirim komen anda</string>
	<string name="reader_toast_err_tag_exists">Anda telahpun mengikut tag ini</string>
	<string name="reader_toast_err_tag_invalid">Ianya bukan tag yang sah</string>
	<string name="reader_toast_err_share_intent">Tidak dapat dikongsi</string>
	<string name="reader_toast_err_view_image">Tidak dapat melihat imej</string>
	<string name="reader_hint_comment_on_comment">Balas ulasan...</string>
	<string name="media_add_popup_title">Tambah ke pustaka media</string>
	<string name="create_account_wpcom">Cipta akaun di WordPress.com</string>
	<string name="reader_empty_followed_tags">Anda tidak mengikut apa-apa tag</string>
	<string name="button_next">Seterusnya</string>
	<string name="stats_totals_plays">Mainan</string>
	<string name="passcode_turn_on">Pasangkan kunci PIN</string>
	<string name="passcode_manage">Urus 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">Tukar PIN</string>
	<string name="passcode_set">Tetapan PIN</string>
	<string name="passcode_preference_title">Kunci PIN</string>
	<string name="passcode_turn_off">Matikan kunci PIN</string>
	<string name="stats_entry_country">Negara</string>
	<string name="stats_entry_posts_and_pages">Tajuk</string>
	<string name="stats_entry_tags_and_categories">Topik</string>
	<string name="stats_entry_authors">Pengarang</string>
	<string name="stats_entry_referrers">Perujuk</string>
	<string name="stats_totals_views">Paparan</string>
	<string name="stats_totals_clicks">Klik</string>
	<string name="post_excerpt">Petikan</string>
	<string name="share_action_title">Tambah ke ...</string>
	<string name="share_action">Kongsi</string>
	<string name="stats">Statistik</string>
	<string name="stats_view_visitors_and_views">Pelawat dan Paparan</string>
	<string name="stats_view_clicks">Klik</string>
	<string name="stats_view_referrers">Perujuk</string>
	<string name="stats_timeframe_today">Hari ini</string>
	<string name="stats_timeframe_yesterday">Kelmarin</string>
	<string name="stats_timeframe_days">Hari</string>
	<string name="stats_timeframe_weeks">Minggu</string>
	<string name="stats_timeframe_months">Bulan</string>
	<string name="media_edit_caption_text">Sari kata</string>
	<string name="media_edit_description_text">Keterangan</string>
	<string name="media_edit_title_hint">Masukkan tajuk di sini</string>
	<string name="media_edit_caption_hint">Masukkan sari kata di sini</string>
	<string name="media_edit_description_hint">Masukkan keterangan di sini</string>
	<string name="media_edit_success">Telah dikemaskini</string>
	<string name="themes">Tema</string>
	<string name="all">Semua</string>
	<string name="images">Imej</string>
	<string name="unattached">Tidak terikat</string>
	<string name="custom_date">Tarikh Disuai</string>
	<string name="media_add_popup_capture_photo">Tangkap gambar</string>
	<string name="media_add_popup_capture_video">Tangkap video</string>
	<string name="media_gallery_image_order_random">Rawak</string>
	<string name="media_gallery_image_order_reverse">Songsang</string>
	<string name="media_gallery_type">Jenis</string>
	<string name="media_gallery_type_squares">Segi empat sama</string>
	<string name="media_gallery_type_tiled">Berjubin</string>
	<string name="media_gallery_type_circles">Bulatan</string>
	<string name="media_gallery_type_slideshow">Persembahan slaid</string>
	<string name="media_edit_title_text">Tajuk</string>
	<string name="themes_features_label">Ciri</string>
	<string name="theme_activate_button">Aktifkan</string>
	<string name="theme_activating_button">Mengaktifkan</string>
	<string name="theme_set_success">Tema berjaya ditetapkan!</string>
	<string name="themes_details_label">Perincian</string>
	<string name="theme_auth_error_title">Gagal mengambil tema</string>
	<string name="media_edit_failure">Gagal mengemas kini</string>
	<string name="stats_view_tags_and_categories">Tag &amp; Kategori</string>
	<string name="upload">Muat naik</string>
	<string name="discard">Buang</string>
	<string name="note_reply_successful">Balasan diterbitkan</string>
	<string name="new_notifications">%d pemberitahuan baharu</string>
	<string name="more_notifications">dan %d lagi.</string>
	<string name="sign_in">Daftar masuk</string>
	<string name="notifications">Pemberitahuan</string>
	<string name="follows">Ikutan</string>
	<string name="loading">Sedang memuat...</string>
	<string name="httpuser">Nama pengguna HTTP</string>
	<string name="httppassword">Kata laluan HTTP</string>
	<string name="error_media_upload">Ralat berlaku semasa memuat naik media</string>
	<string name="post_content">Kandungan (ketik untuk menambah teks dan media)</string>
	<string name="publish_date">Terbit</string>
	<string name="content_description_add_media">Tambah media</string>
	<string name="incorrect_credentials">Nama pengguna atau kata laluan tidak betul.</string>
	<string name="username">Nama pengguna</string>
	<string name="password">Kata laluan</string>
	<string name="reader">Pembaca</string>
	<string name="featured">Guna sebagai imej yang diketengahkan</string>
	<string name="featured_in_post">Sertakan imej dalam kandungan kiriman</string>
	<string name="no_network_title">Tiada rangkaian yang tersedia</string>
	<string name="pages">Laman</string>
	<string name="caption">Sari kata (pilihan)</string>
	<string name="width">Lebar</string>
	<string name="posts">Kiriman</string>
	<string name="anonymous">Tak bernama</string>
	<string name="page">Laman</string>
	<string name="post">Kiriman</string>
	<string name="blogusername">namapenggunablog</string>
	<string name="ok">OK</string>
	<string name="scaled_image">Lebar imej berskala</string>
	<string name="upload_scaled_image">Muat naik dan pautkan ke imej berskala</string>
	<string name="scheduled">Dijadualkan</string>
	<string name="link_enter_url">URL</string>
	<string name="uploading">Memuat naik...</string>
	<string name="version">Versi</string>
	<string name="tos">Terma Perkhidmatan</string>
	<string name="app_title">WordPress untuk Android</string>
	<string name="max_thumbnail_px_width">Lebar Lalai Imej</string>
	<string name="image_alignment">Penjajaran</string>
	<string name="refresh">Segar semula</string>
	<string name="untitled">Tiada tajuk</string>
	<string name="edit">Edit</string>
	<string name="post_id">Kiriman</string>
	<string name="page_id">Laman</string>
	<string name="post_password">Kata laluan (pilihan)</string>
	<string name="immediately">Segera</string>
	<string name="quickpress_add_alert_title">Set nama jalan pintas</string>
	<string name="settings">Tetapan</string>
	<string name="today">Hari Ini</string>
	<string name="share_url">Kongsi URL</string>
	<string name="quickpress_window_title">Pilih blog untuk jalan pintas QuickPress</string>
	<string name="quickpress_add_error">Nama jalan pintas tidak boleh kosong</string>
	<string name="publish_post">Terbit</string>
	<string name="draft">Draf</string>
	<string name="post_private">Sulit</string>
	<string name="upload_full_size_image">Muat naik dan pautkan ke imej penuh</string>
	<string name="tags_separate_with_commas">Tag (pisahkan tag dengan koma)</string>
	<string name="categories">Kategori</string>
	<string name="title">Tajuk</string>
	<string name="dlg_deleting_comments">Menghapuskan ulasan</string>
	<string name="notification_blink">Kerlipkan lampu pemberitahuan</string>
	<string name="notification_vibrate">Getar</string>
	<string name="notification_sound">Bunyi pemberitahuan</string>
	<string name="status">Status</string>
	<string name="location">Lokasi</string>
	<string name="sdcard_title">Kad SD Diperlukan</string>
	<string name="select_video">Pilih video dari galeri</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 gambar daripada galeri</string>
	<string name="error">Ralat</string>
	<string name="cancel">Batal</string>
	<string name="save">Simpan</string>
	<string name="add">Tambah</string>
	<string name="category_refresh_error">Ralat segar semula kategori</string>
	<string name="preview">Pratonton</string>
	<string name="on">on</string>
	<string name="reply">Balas</string>
	<string name="yes">Ya</string>
	<string name="no">Tidak</string>
	<string name="notification_settings">Tetapan Pemberitahuan</string>
</resources>
