<?xml version="1.0" encoding="utf-8"?>
<resources>
	<string name="role_admin">מנהל המערכת</string>
	<string name="role_editor">עורך</string>
	<string name="role_author">מאת</string>
	<string name="role_contributor">תורם</string>
	<string name="role_follower">עוקב</string>
	<string name="role_viewer">צופה</string>
	<string name="error_post_my_profile_no_connection">אין חיבור, הפרופיל לא נשמר</string>
	<string name="site_settings_list_editor_action_mode_title">%1$d נבחרו</string>
	<string name="plans_manage">ניהול התוכנית שלך בכתובת\nWordPress.com/plans</string>
	<string name="title_follower">עוקב</string>
	<string name="people_empty_list_filtered_viewers">אין לך צופים עדיין.</string>
	<string name="title_email_follower">עוקב אימייל</string>
	<string name="people_empty_list_filtered_email_followers">אין לך עוקבים באימייל עדיין.</string>
	<string name="people_empty_list_filtered_followers">אין לך עוקבים עדיין.</string>
	<string name="people_empty_list_filtered_users">אין לך משתמשים עדיין.</string>
	<string name="people_dropdown_item_email_followers">עוקבי אימייל</string>
	<string name="people_dropdown_item_viewers">צופים</string>
	<string name="people_dropdown_item_followers">עוקבים</string>
	<string name="people_dropdown_item_team">צוות</string>
	<string name="invite_message_usernames_limit">אפשר לשלוח עד 10 הזמנות לכתובות אימייל ו/או שמות משתמשים ב-WordPress.com. הוראות ליצירת שם משתמש יישלחו לכל מי שזקוק לשם משתמש.</string>
	<string name="viewer_remove_confirmation_message">לאחר הסרת צופה זה, הוא או היא לא יוכלו לבקר יותר באתר זה.\n\nבחרת להסיר צופה זה - האם ההחלטה סופית?</string>
	<string name="follower_remove_confirmation_message">לאחר הסרת עוקב זה, הוא יפסיק לקבל הודעות לגבי אתר זה, אלא אם יגדיר מעקב מחדש.\n\nבחרת להסיר עוקב זה - האם ההחלטה סופית?</string>
	<string name="follower_subscribed_since">מאז %1$s</string>
	<string name="reader_label_view_gallery">הצגת גלריה</string>
	<string name="error_remove_follower">לא ניתן היה להסיר עוקב</string>
	<string name="error_remove_viewer">לא ניתן היה להסיר צופה</string>
	<string name="error_fetch_email_followers_list">לא הצלחנו לאחזר עוקבי אימייל של האתר</string>
	<string name="error_fetch_followers_list">לא הצלחנו לאחזר עוקבים של האתר</string>
	<string name="editor_failed_uploads_switch_html">מספר העלאות מדיה נכשלו. לא ניתן לעבור למצב HTML\n במצב זה. להסיר את כל ההעלאות שנכשלו ולהמשיך?</string>
	<string name="format_bar_description_html">מצב HTML</string>
	<string name="visual_editor">עורך ויזואלי</string>
	<string name="image_thumbnail">תמונה ממוזערת של תמונה</string>
	<string name="format_bar_description_ul">רשימה לא מסודרת</string>
	<string name="format_bar_description_ol">רשימה מסודרת</string>
	<string name="format_bar_description_more">הוספה</string>
	<string name="format_bar_description_media">הוספת מדיה</string>
	<string name="format_bar_description_quote">ציטוט</string>
	<string name="format_bar_description_strike">קו חוצה</string>
	<string name="format_bar_description_link">הוספת קישור</string>
	<string name="format_bar_description_italic">נטוי</string>
	<string name="format_bar_description_underline">קו תחתון</string>
	<string name="image_width">רוחב</string>
	<string name="format_bar_description_bold">מודגש</string>
	<string name="image_settings_save_toast">שינוי נשמרו</string>
	<string name="image_caption">כיתוב</string>
	<string name="image_alt_text">טקסט חלופי</string>
	<string name="image_link_to">קישור אל</string>
	<string name="image_settings_dismiss_dialog_title">לבטל שינויים שלא נשמרו?</string>
	<string name="stop_upload_dialog_title">לעצור העלאה?</string>
	<string name="stop_upload_button">עצור העלאה</string>
	<string name="alert_error_adding_media">אירעה שגיאה בעת הוספת מדיה</string>
	<string name="alert_action_while_uploading">מתבצעת כרגע העלאת מדיה על-ידך. יש להמתין להשלמת הפעולה.</string>
	<string name="alert_insert_image_html_mode">לא ניתן להוסיף מדיה ישירות במצב HTML. יש לחזור למצב ויזואלי.</string>
	<string name="uploading_gallery_placeholder">מעלה גלריה…</string>
	<string name="invite_error_some_failed">ההזמנה נשלחה אך אירעו שגיאות!</string>
	<string name="invite_sent">ההזמנה נשלחה בהצלחה</string>
	<string name="tap_to_try_again">יש להקיש כדי לנסות שוב!</string>
	<string name="invite_error_for_username">%1$s: %2$s</string>
	<string name="invite_error_sending">אירעה שגיאה בעת הניסיון לשלוח את ההזמנה!</string>
	<string name="invite_error_invalid_usernames_multiple">לא ניתן לשלוח: יש שמות משתמש או כתובות אימייל לא תקפים</string>
	<string name="invite_error_invalid_usernames_one">לא ניתן לשלוח: שם משתמש או אימייל לא תקפים</string>
	<string name="invite_error_no_usernames">יש להוסיף שם משתמש אחד לפחות</string>
	<string name="invite_message_info">(אופציונלי) אפשר להזין הודעה מותאמת אישית של עד 500 תווים שתיכלל בהזמנה למשתמשים.</string>
	<string name="invite_message_remaining_other">נותרו %d תווים</string>
	<string name="invite_message_remaining_one">תו אחד נותר</string>
	<string name="invite_message_remaining_zero">לא נותרו תווים</string>
	<string name="invite_invalid_email">כתובת האימייל \'%s\' לא תקפה</string>
	<string name="invite_message_title">הודעה מותאמת אישית</string>
	<string name="invite_already_a_member">כבר יש חבר בעל שם המשתמש \'%s\'</string>
	<string name="invite_username_not_found">לא נמצא משתמש לשם המשתמש \'%s\'</string>
	<string name="invite">הזמנה</string>
	<string name="invite_names_title">שמות משתמש או אימיילים</string>
	<string name="my_site_header_external">חיצוני</string>
	<string name="send_link">שלח קישור</string>
	<string name="signup_succeed_signin_failed">החשבון שלך נוצר, אך אירעה שגיאה כשהכנסנו אותך\n . יש לנסות להיכנס עם שם המשתמש והסיסמה החדשים שיצרת.</string>
	<string name="invite_people">הזמנת אנשים</string>
	<string name="label_clear_search_history">ניקוי היסטוריית חיפוש</string>
	<string name="dlg_confirm_clear_search_history">לנקות היסטוריית חיפוש?</string>
	<string name="reader_empty_posts_in_search_description">לא נמצאו פוסטים עבור %s בשפה שבחרת</string>
	<string name="reader_label_post_search_running">מחפש...</string>
	<string name="reader_empty_posts_in_search_title">לא נמצאו תוצאות</string>
	<string name="reader_label_related_posts">חומרי קריאה קשורים</string>
	<string name="reader_label_post_search_explainer">חיפוש בכל הבלוגים הציבוריים של WordPress.com</string>
	<string name="reader_hint_post_search">חיפוש ב-WordPress.com</string>
	<string name="reader_title_related_post_detail">באותו נושא</string>
	<string name="reader_title_search_results">חיפוש %s</string>
	<string name="preview_screen_links_disabled">קישורים מושבתים במסך התצוגה המקדימה</string>
	<string name="draft_explainer">פוסט זה הוא טיוטה שלא פורסמה</string>
	<string name="send">שלח</string>
	<string name="user_remove_confirmation_message">לאחר הסרת %1$s, משתמש זה לא יקבל יותר גישה לאתר זה אך כל התוכן שנוצר על ידי %1$s יישאר באתר.\n\nבחרת להסיר משתמש זה - האם ההחלטה סופית?</string>
	<string name="person_removed">הסרת בהצלחה את @%1$s</string>
	<string name="person_remove_confirmation_title">הסרת %1$s</string>
	<string name="reader_empty_posts_in_custom_list">האתרים ברשימה זו לא פרסמו דבר בזמן האחרון</string>
	<string name="people">אנשים</string>
	<string name="edit_user">עריכת פרטי משתמש</string>
	<string name="role">תפקיד</string>
	<string name="error_remove_user">לא ניתן היה להסיר משתמש</string>
	<string name="error_fetch_viewers_list">לא הצלחנו לאחזר את משתמשי האתר</string>
	<string name="error_update_role">לא הצלחנו לעדכן תפקיד משתמש</string>
	<string name="gravatar_camera_and_media_permission_required">דרושות הרשאות לבחירה או לכידה של תמונה</string>
	<string name="error_updating_gravatar">שגיאה בעדכון ה-gravatar שלך</string>
	<string name="error_locating_image">שגיאה באיתור התמונה החתוכה</string>
	<string name="error_refreshing_gravatar">שגיאה בטעינה מחדש של ה-gravatar שלך</string>
	<string name="gravatar_tip">חדש! יש להקיש על ה-gravatar כדי לשנות אותו!</string>
	<string name="error_cropping_image">שגיאה בחיתוך בתמונה</string>
	<string name="launch_your_email_app">הפעלת אפליקציית האימייל</string>
	<string name="checking_email">בודק אימייל</string>
	<string name="not_on_wordpress_com">אינך ב-WordPress.com?</string>
	<string name="magic_link_unavailable_error_message">לא זמין כרגע. יש להזין סיסמה</string>
	<string name="check_your_email">יש לבדוק אימייל</string>
	<string name="get_a_link_sent_to_your_email_to_sign_in_instantly">קבלת קישור להתחברות מיידית באימייל</string>
	<string name="logging_in">נכנס</string>
	<string name="enter_your_password_instead">במקום זאת יש להזין סיסמה</string>
	<string name="web_address_dialog_hint">תוצג באופן ציבורי בעת פרסום תגובות שלך.</string>
	<string name="jetpack_not_connected_message">תוסף Jetpack מותקן אבל לא מחובר ל-WordPress.com. האם ברצונך לחבר את Jetpack?</string>
	<string name="username_email">אימייל או שם משתמש</string>
	<string name="jetpack_not_connected">תוסף Jetpack לא מחובר</string>
	<string name="new_editor_reflection_error">עורך ויזואלי לא תואם למכשיר שלך. הוא\n הושבת אוטומטית.</string>
	<string name="stats_insights_latest_post_no_title">(חסרה כותרת)</string>
	<string name="capture_or_pick_photo">בחירה או לכידה של תמונה</string>
	<string name="plans_post_purchase_text_themes">כעת יש לך גישה בלתי מוגלת לערכות פרימיום. בתור התחלה, אפשר להציג כל אחת מהן בתצוגה מקדימה.</string>
	<string name="plans_post_purchase_button_themes">חיפוש ערכות עיצוב</string>
	<string name="plans_post_purchase_title_themes">מציאת ערכת פרימיום מושלמת</string>
	<string name="plans_post_purchase_button_video">יצירת פוסט חדש</string>
	<string name="plans_post_purchase_text_video">אפשר להעלות ולאחסן סרטוני וידאו באתר שלך דרך VideoPress ואחסון המדיה המורחב שלך.</string>
	<string name="plans_post_purchase_title_video">סרטונים שיפיחו חיים בפוסטים</string>
	<string name="plans_post_purchase_button_customize">התאמה אישית של האתר</string>
	<string name="plans_post_purchase_text_customize">כעת יש לך גישה לגופנים מותאמים אישית, צבעים מותאמים אישית יכולות עריכה של CSS מותאם אישית.</string>
	<string name="plans_post_purchase_text_intro">האתר שלך עושה סלטות מרוב התרגשות! זה הזמן לגלות את התכונות החדשות של האתר שלך ולבחור במה להתחיל.</string>
	<string name="plans_post_purchase_title_customize">התאמה אישית של גופנים וצבעים</string>
	<string name="plans_post_purchase_title_intro">הכול שלך, כל הכבוד!</string>
	<string name="export_your_content_message">הפוסטים, העמודים וההגדרות שלך יישלחו באימייל לכתובת %s.</string>
	<string name="plan">תוכנית</string>
	<string name="plans">תוכניות</string>
	<string name="plans_loading_error">לא ניתן לטעון תוכניות</string>
	<string name="export_your_content">יצוא התוכן שלך</string>
	<string name="exporting_content_progress">מייצא תוכן…</string>
	<string name="export_email_sent">אימייל יצוא נשלח!</string>
	<string name="premium_upgrades_message">קיימים שדרוגים פעילים באתר שלך. יש לבטל את השדרוגים לפני מחיקת האתר.</string>
	<string name="show_purchases">הצגת רכישות</string>
	<string name="checking_purchases">בודק רכישות</string>
	<string name="premium_upgrades_title">שדרוגים</string>
	<string name="purchases_request_error">משהו השתבש. לא ניתן לבקש רכישות.</string>
	<string name="delete_site_progress">מוחק אתר…</string>
	<string name="delete_site_summary">לא ניתן לבטל פעולה זו. מחיקת האתר שלך תסיר את כל התוכן, המשתתפים והדומיינים מהאתר.</string>
	<string name="delete_site_hint">מחיקת אתר</string>
	<string name="export_site_hint">יצוא האתר שלך לקובץ XML</string>
	<string name="are_you_sure">ההחלטה הסופית?</string>
	<string name="export_site_summary">אם ההחלטה שלך סופית, זה הזמן לייצא את התוכן שלך. לא ניתן יהיה לשחזר אותו בעתיד.</string>
	<string name="keep_your_content">שמירת התוכן שלך</string>
	<string name="domain_removal_hint">הדומיינים לא יעבדו עוד לאחר הסרת האתר</string>
	<string name="domain_removal_summary">זהירות! מחיקת האתר שלך תסיר גם את הדומיינים להלן.</string>
	<string name="primary_domain">דומיין ראשי</string>
	<string name="domain_removal">הסרת דומיין</string>
	<string name="error_deleting_site_summary">אירעה שגיאה בעת מחיקת האתר שלך. כדאי לפנות לתמיכה לקבלת סיוע נוסף</string>
	<string name="error_deleting_site">שגיאה בעת מחיקת האתר</string>
	<string name="confirm_delete_site_prompt">יש להקליד את הכתובת %1$s בשדה להלן כדי לאשר. לאחר מכן, האתר שלך ייעלם לעד.</string>
	<string name="site_settings_export_content_title">יצוא תוכן</string>
	<string name="contact_support">כדאי לפנות לתמיכה</string>
	<string name="confirm_delete_site">אישור מחיקת אתר</string>
	<string name="start_over_text">אם ברצונך להשתמש באתר בלי הפוסטים והעמודים שהוא מכיל, צוות התמיכה שלנו יכול למחוק את הפוסטים, העמודים, המדיה והתגובות עבורך.\n\nכך האתר וכתובת ה-URL שלך יישארו פעילים אבל תהיה לך אפשרות להתחיל ליצור תוכן מחדש. נותר לך רק לפנות אלינו כדי למחוק את התוכן הקיים.</string>
	<string name="site_settings_start_over_hint">הקמת האתר מחדש</string>
	<string name="let_us_help">נשמח לעזור</string>
	<string name="me_btn_app_settings">הגדרות יישום</string>
	<string name="start_over">להתחיל מחדש</string>
	<string name="editor_remove_failed_uploads">הסרת העלאות שנכשלו</string>
	<string name="editor_toast_failed_uploads">מספר העלאות מדיה נכשלו. לא ניתן לשמור או לפרסם\n הפוסט שלך במצב זה. האם ברצונך להסיר את כל המדיה שלא הועלתה?</string>
	<string name="comments_empty_list_filtered_trashed">אין תגובות שהועברו לפח</string>
	<string name="site_settings_advanced_header">אפשרויות מתקדמות</string>
	<string name="comments_empty_list_filtered_pending">אין תגובות שממתינות לאישור</string>
	<string name="comments_empty_list_filtered_approved">אין תגובות מאושרות</string>
	<string name="button_done">בוצע</string>
	<string name="button_skip">דילוג</string>
	<string name="site_timeout_error">לא ניתן להתחבר ל-WordPress עקב שגיאה - תם הזמן הקצוב.</string>
	<string name="xmlrpc_malformed_response_error">לא ניתן להתחבר. התקנת WordPress הגיבה עם מסמך XML-RPC לא תקף.</string>
	<string name="xmlrpc_missing_method_error">לא ניתן להתחבר. שיטות XML-RPC נדרשות חסרות בשרת.</string>
	<string name="post_format_video">וידאו</string>
	<string name="theme_free">חינם</string>
	<string name="theme_premium">פרימיום</string>
	<string name="post_format_status">מצב</string>
	<string name="theme_all">הכול</string>
	<string name="post_format_chat">צ\'אט</string>
	<string name="post_format_image">תמונה</string>
	<string name="post_format_link">קישור</string>
	<string name="post_format_quote">ציטוט</string>
	<string name="post_format_gallery">גלריה</string>
	<string name="post_format_standard">פוסט רגיל</string>
	<string name="post_format_audio">אודיו</string>
	<string name="notif_events">מידע על קורסים ואירועים ב-WordPress.com (ברשת ופרונטלי).</string>
	<string name="post_format_aside">קצרצר</string>
	<string name="notif_surveys">הזדמנויות להשתתף במחקרים וסקרים של WordPress.com.</string>
	<string name="notif_tips">טיפים כדי להפיק את המרב מ-WordPress.com.</string>
	<string name="notif_community">קהילה</string>
	<string name="notif_suggestions">הצעות</string>
	<string name="replies_to_my_comments">מענה לתגובות שלי</string>
	<string name="notif_research">מחקר</string>
	<string name="site_achievements">הישגי אתר</string>
	<string name="username_mentions">אזכורים של שם משתמש</string>
	<string name="likes_on_my_posts">לייקים בפוסטים שלי</string>
	<string name="site_follows">עוקבים אחרי האתר</string>
	<string name="likes_on_my_comments">לייקים בתגובות שלי</string>
	<string name="comments_on_my_site">תגובות באתר שלי</string>
	<string name="site_settings_list_editor_summary_other">%d פריטים</string>
	<string name="site_settings_list_editor_summary_one">פריט אחד</string>
	<string name="approve_auto">כל המשתמשים</string>
	<string name="approve_auto_if_previously_approved">תגובות של משתמשים מוכרים</string>
	<string name="approve_manual">אין תגובות</string>
	<string name="site_settings_paging_summary_other">%d תגובות לעמוד</string>
	<string name="site_settings_paging_summary_one">תגובה אחת לעמוד</string>
	<string name="site_settings_multiple_links_summary_other">נדרש אישור עבור יותר מ-%d קישורים</string>
	<string name="site_settings_multiple_links_summary_one">נדרש אישור עבור יותר מקישור אחד</string>
	<string name="site_settings_multiple_links_summary_zero">נדרש אישור עבור יותר מ-0 קישורים</string>
	<string name="detail_approve_auto">אישור אוטומטי של תגובות מכולם.</string>
	<string name="detail_approve_auto_if_previously_approved">אישור אוטומטי אם תגובה קודמת של המשתמש אושרה</string>
	<string name="detail_approve_manual">אישור ידני דרוש לתגובות מכולם.</string>
	<string name="days_quantity_one">יום אחד</string>
	<string name="days_quantity_other">%d ימים</string>
	<string name="filter_trashed_posts">הועבר לפח</string>
	<string name="filter_published_posts">פורסם</string>
	<string name="filter_draft_posts">טיוטות</string>
	<string name="filter_scheduled_posts">מתוזמן לפרסום</string>
	<string name="primary_site">אתר ראשי</string>
	<string name="pending_email_change_snackbar">יש ללחוץ על הקישור לאימות באימייל שנשלח לכתובת %1$s כדי לאשר את כתובתך החדשה</string>
	<string name="web_address">כתובת URL</string>
	<string name="editor_toast_uploading_please_wait">מתבצעת כרגע העלאת מדיה על-ידך. יש להמתין להשלמת הפעולה.</string>
	<string name="error_refresh_comments_showing_older">לא ניתן לרענן תגובות כרגע - מציג תגובות ישנות</string>
	<string name="editor_post_settings_set_featured_image">קביעת תמונה מרכזית</string>
	<string name="editor_post_settings_featured_image">תמונה מרכזית</string>
	<string name="new_editor_promo_desc">אפליקציית WordPress עבור Android כוללת כעת עורך ויזואלי חדש\n ויפהפה. ניתן להתנסות בו על ידי יצירת פוסט חדש.</string>
	<string name="new_editor_promo_title">עורך חדש ומחודש</string>
	<string name="new_editor_promo_button_label">נהדר, תודה!</string>
	<string name="visual_editor_enabled">עורך ויזואלי מופעל</string>
	<string name="editor_content_placeholder">מומלץ לשתף את הסיפור שלך כאן…</string>
	<string name="editor_page_title_placeholder">כותרת עמוד</string>
	<string name="editor_post_title_placeholder">כותרת הפוסט</string>
	<string name="email_address">כתובת אימייל</string>
	<string name="preference_show_visual_editor">הצגת עורך ויזואלי</string>
	<string name="preference_editor">עורך</string>
	<string name="dlg_sure_to_delete_comments">האם למחוק תגובות אלה לצמיתות?</string>
	<string name="dlg_sure_to_delete_comment">האם למחוק תגובה זו לצמיתות?</string>
	<string name="mnu_comment_delete_permanently">מחיקה</string>
	<string name="comment_deleted_permanently">התגובה נמחקה</string>
	<string name="mnu_comment_untrash">שחזור</string>
	<string name="comments_empty_list_filtered_spam">אין תגובות זבל</string>
	<string name="could_not_load_page">לא ניתן היה לטעון את העמוד</string>
	<string name="comment_status_all">הכול</string>
	<string name="interface_language">שפת ממשק</string>
	<string name="off">כיבוי</string>
	<string name="about_the_app">מידע על האפליקציה</string>
	<string name="error_post_account_settings">לא ניתן לשמור הגדרות החשבון</string>
	<string name="error_post_my_profile">הפרופיל לא נשמר</string>
	<string name="error_fetch_account_settings">לא ניתן לאחזר את הגדרות החשבון שלך</string>
	<string name="error_fetch_my_profile">לא ניתן לאחזר את הפרופיל שלך</string>
	<string name="stats_widget_promo_ok_btn_label">אוקי, הבנתי</string>
	<string name="stats_widget_promo_desc">להוסיף את הווידג׳ט למסך הבית כדי להגיע לסטטיסטיקות בקליק אחד.</string>
	<string name="stats_widget_promo_title">וידג׳ט סטטיסטיקות למסך הבית</string>
	<string name="site_settings_unknown_language_code_error">קוד שפה לא מזוהה</string>
	<string name="site_settings_threading_dialog_description">אפשר תגובות משורשרות</string>
	<string name="site_settings_threading_dialog_header">שרשור עד עומק של</string>
	<string name="search">לחפש</string>
	<string name="add_category">הוספת קטגוריה</string>
	<string name="remove">להסיר</string>
	<string name="disabled">לא מופעל</string>
	<string name="site_settings_image_original_size">גודל מקורי</string>
	<string name="privacy_private">האתר גלוי רק לך ולמשתמשים שאישרת</string>
	<string name="privacy_public_not_indexed">האתר שלך גלוי לכולם אבל שולח בקשה למנועי חיפוש לא לצרף אותו לאינדקס</string>
	<string name="privacy_public">האתר שלך גלוי לכולם ומנועי חיפוש יכולים לצרף אותו לאינדקס</string>
	<string name="about_me_hint">תיאור אישי בכמה מילים…</string>
	<string name="public_display_name_hint">אם לא יוגדר אחרת, שם המשתמש שלך ישמש כשם תצוגה בברירת מחדל</string>
	<string name="about_me">מי אני</string>
	<string name="public_display_name">שם תצוגה ציבורי</string>
	<string name="my_profile">הפרופיל שלי</string>
	<string name="first_name">שם פרטי</string>
	<string name="last_name">שם משפחה</string>
	<string name="site_privacy_public_desc">לאפשר למנועי חיפוש לצרף את האתר לאינדקס</string>
	<string name="site_privacy_hidden_desc">למנוע ממנועי חיפוש לצרף את האתר לאינדקס</string>
	<string name="site_privacy_private_desc">אני רוצה שהאתר שלי יהיה פרטי וגלוי רק למשתמשים שאבחר</string>
	<string name="cd_related_post_preview_image">תמונת תצוגה מקדימה של פוסט קשור</string>
	<string name="error_post_remote_site_settings">לא הצלחנו לשמור את פרטי האתר</string>
	<string name="error_fetch_remote_site_settings">לא הצלחנו לאחזר את פרטי האתר</string>
	<string name="error_media_upload_connection">ארעה שגיאת חיבור במהלך העלאת המדיה</string>
	<string name="site_settings_disconnected_toast">מנותק, עריכה מושבתת.</string>
	<string name="site_settings_unsupported_version_error">גרסת WordPress לא נתמכת</string>
	<string name="site_settings_multiple_links_dialog_description">דרוש אישור לתגובות שכוללות כמות קישורים גבוהה מזו.</string>
	<string name="site_settings_close_after_dialog_switch_text">סגירה אוטומטית</string>
	<string name="site_settings_close_after_dialog_description">סגירת תגובות אוטומטית במאמרים.</string>
	<string name="site_settings_paging_dialog_description">חלוקת שרשורי תגובות למספר עמודים.</string>
	<string name="site_settings_paging_dialog_header">תגובות לעמוד</string>
	<string name="site_settings_close_after_dialog_title">סגור לתגובות</string>
	<string name="site_settings_blacklist_description">תגובה שתכיל מילה מהמילים הללו בתוכן שלה, בשם, בכתובת, באימייל או ב-IP תסומן כתגובת זבל. אפשר להשתמש גם בחלקי מילים, כך ש-"press" תתאים למילה "WordPress".</string>
	<string name="site_settings_hold_for_moderation_description">תגובה שתכיל מילה מהמילים הללו בתוכן שלה, בשם, בכתובת האתר, באימייל או ב-IP תישמר בתור המנהל. אפשר להשתמש גם בחלקי מילים, כך ש-"press" תתאים למילה "WordPress".</string>
	<string name="site_settings_list_editor_input_hint">הזנת מילה או ביטוי</string>
	<string name="site_settings_list_editor_no_items_text">אין פריטים</string>
	<string name="site_settings_learn_more_caption">אפשר לעקוף הגדרות אלה בפוסטים נפרדים.</string>
	<string name="site_settings_rp_preview3_site">תחת \'שדרוג\'</string>
	<string name="site_settings_rp_preview3_title">המלצת שדרוג: VideoPress לחתונות</string>
	<string name="site_settings_rp_preview2_site">תחת \'אפליקציות\'</string>
	<string name="site_settings_rp_preview2_title">אפליקציית WordPress ל-Android עברה \'מתיחת פנים\' רצינית</string>
	<string name="site_settings_rp_preview1_site">תחת \'נייד\'</string>
	<string name="site_settings_rp_preview1_title">עדכון גדול ל-iPhone/‏iPad זמין עכשיו</string>
	<string name="site_settings_rp_show_images_title">הצגת תמונות</string>
	<string name="site_settings_rp_show_header_title">הצגת כותרת</string>
	<string name="site_settings_rp_switch_summary">פוסטים קשורים מציגים תוכן רלוונטי מהאתר שלך, מתחת לפוסטים שלך.</string>
	<string name="site_settings_rp_switch_title">הצג תכנים באותו נושא</string>
	<string name="site_settings_delete_site_hint">מסיר את נתוני האתר שלך מהאפליקציה</string>
	<string name="site_settings_blacklist_hint">תגובות שתואמות למסנן מסומנות כתגובות זבל</string>
	<string name="site_settings_moderation_hold_hint">תגובות שתואמות למסנן עוברות לתור לאישור</string>
	<string name="site_settings_multiple_links_hint">מתעלם ממגבלת קישורים אצל משתמשים מוכרים</string>
	<string name="site_settings_whitelist_hint">המגיב הוא מישהו שתגובתו אושרה בעבר</string>
	<string name="site_settings_user_account_required_hint">כדי להגיב יש להירשם לאתר ולהתחבר למערכת</string>
	<string name="site_settings_identity_required_hint">המגיבים חייבים לכתוב את שמם ואת כתובת האימייל שלהם</string>
	<string name="site_settings_manual_approval_hint">תגובות חייבות לעבור אישור ידני</string>
	<string name="site_settings_paging_hint">הצגת כמות מוגדרת של תגובות</string>
	<string name="site_settings_threading_hint">מאפשר שרשור תגובות עד עומק מסוים</string>
	<string name="site_settings_sort_by_hint">קובע את סדר הצגת התגובות</string>
	<string name="site_settings_close_after_hint">לא מאפשר הוספת תגובות אחרי פרק זמן מוגדר</string>
	<string name="site_settings_receive_pingbacks_hint">מאפשר קבלת הודעות עם קישורים מבלוגים אחרים</string>
	<string name="site_settings_send_pingbacks_hint">מנסה לשלוח הודעה לכל בלוג שהמאמר מקשר אליו</string>
	<string name="site_settings_allow_comments_hint">מאפשר לקוראים לפרסם תגובות</string>
	<string name="site_settings_discussion_hint">הצגה ושינוי של הגדרות הדיון באתרים שלך</string>
	<string name="site_settings_more_hint">הצגת כל הגדרות הדיון הזמינות</string>
	<string name="site_settings_related_posts_hint">הצגה/הסתרה של פוסטים קשורים ב-Reader</string>
	<string name="site_settings_upload_and_link_image_hint">מאפשר תמיד להעלות תמונה בגודל מלא</string>
	<string name="site_settings_image_width_hint">שינוי גודל של תמונות בפוסטים לרוחב זה</string>
	<string name="site_settings_format_hint">הגדרת סוג פוסט חדש</string>
	<string name="site_settings_category_hint">הגדרת קטגוריית פוסט חדשה</string>
	<string name="site_settings_location_hint">הוספה אוטומטית של נתוני מיקום לפוסטים שלך</string>
	<string name="site_settings_password_hint">שינוי סיסמה</string>
	<string name="site_settings_username_hint">חשבון משתמש נוכחי</string>
	<string name="site_settings_language_hint">השפה עיקרית בה כתוב בלוג זה</string>
	<string name="site_settings_privacy_hint">מגדיר מי יכול לראות את האתר שלך</string>
	<string name="site_settings_address_hint">האפשרות לשינוי כתובת לא נתמכת כרגע</string>
	<string name="site_settings_tagline_hint">תיאור קצר או ביטוי קולע שמתארים את הבלוג שלך</string>
	<string name="site_settings_title_hint">במספר מילים, הסבר במה עוסק האתר</string>
	<string name="site_settings_whitelist_known_summary">תגובות ממשתמשים מוכרים</string>
	<string name="site_settings_whitelist_all_summary">תגובות מכל המשתמשים</string>
	<string name="site_settings_threading_summary">%d רמות</string>
	<string name="site_settings_privacy_private_summary">פרטי</string>
	<string name="site_settings_privacy_hidden_summary">מוסתר</string>
	<string name="site_settings_delete_site_title">מחיקת אתר</string>
	<string name="site_settings_privacy_public_summary">ציבורי</string>
	<string name="site_settings_blacklist_title">רשימה שחורה</string>
	<string name="site_settings_moderation_hold_title">המתנה לניהול</string>
	<string name="site_settings_multiple_links_title">קישורים בתגובות</string>
	<string name="site_settings_whitelist_title">אישור אוטומטי</string>
	<string name="site_settings_threading_title">שרשור</string>
	<string name="site_settings_paging_title">עימוד</string>
	<string name="site_settings_sort_by_title">מיון לפי</string>
	<string name="site_settings_account_required_title">משתמשים חייבים להתחבר</string>
	<string name="site_settings_identity_required_title">חובה לציין שם ואימייל</string>
	<string name="site_settings_receive_pingbacks_title">קבלת פינגבאקים</string>
	<string name="site_settings_send_pingbacks_title">שליחת פינגבאקים</string>
	<string name="site_settings_allow_comments_title">אפשר תגובות</string>
	<string name="site_settings_default_format_title">סוג ברירת מחדל</string>
	<string name="site_settings_default_category_title">קטגוריית ברירת מחדל</string>
	<string name="site_settings_location_title">אפשר מיקום</string>
	<string name="site_settings_address_title">כתובת</string>
	<string name="site_settings_title_title">שם האתר</string>
	<string name="site_settings_tagline_title">תיאור האתר</string>
	<string name="site_settings_this_device_header">מכשיר זה</string>
	<string name="site_settings_discussion_new_posts_header">ברירות מחדל עבור פוסטים חדשים</string>
	<string name="site_settings_account_header">חשבון</string>
	<string name="site_settings_writing_header">כתיבה</string>
	<string name="site_settings_general_header">כללי</string>
	<string name="newest_first">חדשים תחילה</string>
	<string name="discussion">דיון</string>
	<string name="privacy">פרטיות</string>
	<string name="comments">תגובות</string>
	<string name="close_after">סגור אחרי</string>
	<string name="related_posts">באותו נושא</string>
	<string name="oldest_first">ישנים תחילה</string>
	<string name="media_error_no_permission_upload">אין לך הרשאה להעלות מדיה לאתר</string>
	<string name="never">לעולם לא</string>
	<string name="unknown">לא ידוע</string>
	<string name="reader_err_get_post_not_found">הפוסט כבר לא קיים</string>
	<string name="reader_err_get_post_not_authorized">אינך רשאי לראות פוסט זה</string>
	<string name="reader_err_get_post_generic">לא ניתן לאחזר פוסט זה</string>
	<string name="blog_name_no_spaced_allowed">כתובת האתר לא יכולה להכיל רווחים</string>
	<string name="invalid_username_no_spaces">שם המשתמש לא יכול להכיל רווחים</string>
	<string name="reader_empty_followed_blogs_no_recent_posts_description">האתרים אחריהם אתה עוקב לא פרסמו דבר לאחרונה</string>
	<string name="reader_empty_followed_blogs_no_recent_posts_title">אין פוסטים אחרונים</string>
	<string name="edit_media">עריכת מדיה</string>
	<string name="media_details_copy_url_toast">הכתובת הועתקה ללוח העריכה</string>
	<string name="media_details_copy_url">העתק כתובת</string>
	<string name="media_details_label_date_uploaded">הועלה</string>
	<string name="media_details_label_date_added">התווסף</string>
	<string name="selected_theme">תבנית נבחרת</string>
	<string name="could_not_load_theme">לא ניתן לטעון תבנית</string>
	<string name="theme_activation_error">משהו השתבש. לאניתן להפעיל תבנית</string>
	<string name="theme_by_author_prompt_append">מאת %1$s</string>
	<string name="theme_prompt">תודה שבחרת %1$s</string>
	<string name="theme_view">הצג</string>
	<string name="theme_details">פרטים</string>
	<string name="theme_support">תמיכה</string>
	<string name="theme_done">הושלם</string>
	<string name="theme_manage_site">ניהול אתר</string>
	<string name="theme_try_and_customize">נסה והתאם אישית</string>
	<string name="title_activity_theme_support">תבניות</string>
	<string name="theme_activate">הפעלה</string>
	<string name="date_range_start_date">תאריך התחלה</string>
	<string name="date_range_end_date">תאריך סיום</string>
	<string name="current_theme">תבנית נוכחית</string>
	<string name="details">פרטים</string>
	<string name="support">תמיכה</string>
	<string name="customize">התאמה אישית</string>
	<string name="active">פעיל</string>
	<string name="stats_referrers_spam_generic_error">משהו השתבש במהלך הפעולה. הסטטוס של הספאם לא השתנה.</string>
	<string name="stats_referrers_marking_not_spam">מסמן כלא זבל</string>
	<string name="stats_referrers_unspam">לא ספאם</string>
	<string name="stats_referrers_marking_spam">מסמן כזבל</string>
	<string name="stats_referrers_spam">ספאם</string>
	<string name="post_published">פוסט פורסם</string>
	<string name="page_published">עמוד פורסם</string>
	<string name="post_updated">פוסט עודכן</string>
	<string name="page_updated">עמוד עודכן</string>
	<string name="theme_auth_error_authenticate">נכשל בניסיון להביא תבניות: נכשל אימות משתמש</string>
	<string name="theme_no_search_result_found">לא נמצאו תבניות.</string>
	<string name="media_file_name">שם קובץ: %s</string>
	<string name="media_uploaded_on">תאריך העלאה: %s</string>
	<string name="media_dimensions">מימדים: %s</string>
	<string name="media_file_type">סוג קובץ: %s</string>
	<string name="upload_queued">בתור</string>
	<string name="reader_label_gap_marker">פוסטים נוספים</string>
	<string name="notifications_no_search_results">אף אתר אינו תואם \'%s\'</string>
	<string name="search_sites">חיפוש אתרים</string>
	<string name="unread">לא נקרא</string>
	<string name="notifications_empty_view_reader">הצד קורא</string>
	<string name="notifications_empty_action_followers_likes">קבל תשומת לב: תגובה לפוסטים שכבר קראת.</string>
	<string name="notifications_empty_action_comments">הצטרף לדיון: תגובות לפוסטים באתרים אחריהם אתה עוקב.</string>
	<string name="notifications_empty_action_unread">הצת מחדש את הדיון: כתוב פוסט חדש.</string>
	<string name="notifications_empty_action_all">תהיה פעיל! תגיב לפוסטים באתרים אחריהם אתה עוקב.</string>
	<string name="notifications_empty_likes">אין לייקים חדשים... עדיין.</string>
	<string name="notifications_empty_followers">אין עוקבים חדשים... עדיין.</string>
	<string name="notifications_empty_comments">אין תגובות חדשות... עדיין.</string>
	<string name="notifications_empty_unread">כולכם נתפסתם!</string>
	<string name="stats_widget_error_jetpack_no_blogid">נא לגשת לסטטיסטיקות באפליקציה ולהוסיף וידג\'ט</string>
	<string name="stats_widget_error_readd_widget">יש להסיר את הוידג\'ט ולהוסיף אותו שוב</string>
	<string name="stats_widget_error_no_visible_blog">לא ניתן לגשת לסטטיסטיקות ללא אתר גלוי</string>
	<string name="stats_widget_error_no_permissions">לא ניתן לגשת לסטטיסטיקות באתר זה באמצעות חשבון וורדפרס.קום זה</string>
	<string name="stats_widget_error_no_account">נא להתחברת לוורדפרס</string>
	<string name="stats_widget_error_generic">לא ניתן לטעון סטטיסטיקות</string>
	<string name="stats_widget_loading_data">טוען נתונים...</string>
	<string name="stats_widget_name_for_blog">סטטיסטיקות יומיות עבור %1$s</string>
	<string name="stats_widget_name">סטטיסטיקות וורדפרס יומיות</string>
	<string name="add_location_permission_required">נדרשות הרשאות מתאימות כדי להוסיף מיקומים</string>
	<string name="add_media_permission_required">ההרשאות הדרושות כדי להוסיף מדיה</string>
	<string name="access_media_permission_required">ההרשאות הדרושות כדי לגשת למדיה</string>
	<string name="stats_enable_rest_api_in_jetpack">להצגת סטטיסטיקות, הפעילו מודול JSON API בג\'טפאק.</string>
	<string name="error_open_list_from_notification">פוסט או עמוד זה פורסם באתר אחר</string>
	<string name="reader_short_comment_count_multi">%s תגובות</string>
	<string name="reader_short_comment_count_one">תגובה אחת</string>
	<string name="reader_label_submit_comment">שלח</string>
	<string name="reader_hint_comment_on_post">מענה לפוסט...</string>
	<string name="reader_discover_visit_blog">בקר ב%s</string>
	<string name="reader_discover_attribution_blog">פורסם במקור ב-%s</string>
	<string name="reader_discover_attribution_author">פורסם במקור על ידי %s</string>
	<string name="reader_discover_attribution_author_and_blog">פורסם במקור על ידי %1$s ב-%2$s</string>
	<string name="reader_short_like_count_multi">%s לייקים</string>
	<string name="reader_short_like_count_one">לייק אחד</string>
	<string name="reader_short_like_count_none">לייק</string>
	<string name="reader_label_follow_count">%,d עוקבים</string>
	<string name="reader_menu_tags">עריכת תגיות ובלוגים</string>
	<string name="reader_title_post_detail">קורא פוטס</string>
	<string name="local_draft_explainer">לפוסט זה יש טיוטה מקומית שלא פורסמה</string>
	<string name="local_changes_explainer">לפוסט זה יש שינויים מקומיים שטרם פורסמו</string>
	<string name="notifications_push_summary">הגדרת התראות יוצגו במכשיר שלך. </string>
	<string name="notifications_email_summary">הגדרת התראות שישלחו לאימייל של בעל האתר.</string>
	<string name="notifications_tab_summary">הגדרת התראות יוצגו בטאב ההתראות.</string>
	<string name="notifications_disabled">התראות אפליקציה הוסרו. ליחצו כאן כדי להפעיל שוב בהגדרות.</string>
	<string name="notification_types">סוגי התראות</string>
	<string name="error_loading_notifications">לא ניתן לטעון הגדרות של התראות</string>
	<string name="replies_to_your_comments">מענה לתגובות שלך</string>
	<string name="comment_likes">לייקים לתגובות</string>
	<string name="email">אימייל</string>
	<string name="notifications_tab">טאב התראות</string>
	<string name="app_notifications">התראות אפליקציה</string>
	<string name="notifications_comments_other_blogs">תגובות באתרים אחרים</string>
	<string name="notifications_other">אחר</string>
	<string name="notifications_wpcom_updates">עדכוני וורדפרס.קום</string>
	<string name="notifications_account_emails">עדכונים מוורדפרס.קום</string>
	<string name="notifications_account_emails_summary">תמיד נשלח מיילים חשובים הקשורים לאתר, אבל לפעמים תקבלו גם תוספות מועילות.</string>
	<string name="your_sites">אתרים שלך</string>
	<string name="notifications_sights_and_sounds">מראות וצלילים</string>
	<string name="stats_insights_latest_post_trend">עברו %1$s מאז פרסום %2$s. קצת מידע על תפקוד הפוסט עד כה...</string>
	<string name="stats_insights_latest_post_summary">סיכום פוסטים אחרונים</string>
	<string name="button_revert">שיחזור</string>
	<string name="days_ago">לפני %d ימים</string>
	<string name="yesterday">אתמול</string>
	<string name="connectionbar_no_connection">אין חיבור</string>
	<string name="page_trashed">העמוד הועבר לפח</string>
	<string name="post_deleted">הפוסט נמחק</string>
	<string name="post_trashed">הפוסט הועבר לפח</string>
	<string name="stats_no_activity_this_period">אין פעילות בפרק זמן זה</string>
	<string name="trashed">הועבר לפח</string>
	<string name="button_back">חזרה</string>
	<string name="page_deleted">העמוד נמחק</string>
	<string name="button_stats">נתונים סטטיסטיים</string>
	<string name="button_trash">פח</string>
	<string name="button_preview">תצוגה מקדימה</string>
	<string name="button_view">הצגה</string>
	<string name="button_edit">עריכה</string>
	<string name="button_publish">פרסום</string>
	<string name="my_site_no_sites_view_subtitle">האם תרצה להוסיף אחד?</string>
	<string name="my_site_no_sites_view_title">עדיין אין לך אתרי וורדפרס.</string>
	<string name="my_site_no_sites_view_drake">אילוסטרציה</string>
	<string name="reader_toast_err_follow_blog_not_authorized">אינך מורשה להיכנס לבלוג</string>
	<string name="reader_toast_err_follow_blog_not_found">הבלוג לא נמצא</string>
	<string name="undo">ביטול פעולה אחרונה</string>
	<string name="tabbar_accessibility_label_my_site">האתר שלי</string>
	<string name="tabbar_accessibility_label_me">אני</string>
	<string name="passcodelock_prompt_message">הזנת קוד PIN</string>
	<string name="editor_toast_changes_saved">השינויים נשמרו</string>
	<string name="push_auth_expired">פג תוקף הבקשה. יש להיכנס לוורדפרס.קום כדי לנסות שוב.</string>
	<string name="stats_insights_most_popular_percent_views">%1$d%% מהצפיות</string>
	<string name="stats_insights_best_ever">כמות הצפיות הגבוהה בכל הזמנים</string>
	<string name="ignore">להתעלם</string>
	<string name="stats_insights_most_popular_hour">השעה הפופולרית ביותר</string>
	<string name="stats_insights_most_popular_day">היום הפופולרי ביותר</string>
	<string name="stats_insights_popular">היום והשעה הפופולרים ביותר</string>
	<string name="stats_insights_today">הנתונים הסטטיסטיים של היום</string>
	<string name="stats_insights_all_time">פוסטים, צפיות ומבקרים מההתחלה ועד היום</string>
	<string name="stats_insights">תובנות</string>
	<string name="stats_sign_in_jetpack_different_com_account">להצגת הנתונים הסטטיסטיים שלך, יש להיכנס לוורדפרס.קום שבו השתמשת כדי לחבר את Jetpack.</string>
	<string name="stats_other_recent_stats_moved_label">מנסה למצוא נתונים סטטיסטיים אחרים מהזמן האחרון? העברנו אותם אל העמוד \'תובנות\'.</string>
	<string name="me_disconnect_from_wordpress_com">התנתקות מוורדפרס.קום</string>
	<string name="me_btn_login_logout">כניסה/יציאה</string>
	<string name="me_connect_to_wordpress_com">התחברת לוורדפרס.קום</string>
	<string name="site_picker_cant_hide_current_site">"%s" לא הוסתר מכיוון שזהו האתר הנוכחי</string>
	<string name="account_settings">הגדרות חשבון</string>
	<string name="me_btn_support">עזרה ותמיכה</string>
	<string name="site_picker_create_dotcom">יצירת אתר וורדפרס.קום</string>
	<string name="site_picker_edit_visibility">הצגת/הסתרת אתרים</string>
	<string name="site_picker_add_self_hosted">הוספת אתר באחסון עצמי</string>
	<string name="site_picker_add_site">הוספת אתר</string>
	<string name="site_picker_title">בחירת אתר</string>
	<string name="my_site_btn_switch_site">החלפת אתר</string>
	<string name="my_site_btn_view_admin">הצגת מנהל מערכת</string>
	<string name="my_site_btn_view_site">הצגת אתר</string>
	<string name="my_site_header_publish">פרסום</string>
	<string name="my_site_header_look_and_feel">סגנון</string>
	<string name="my_site_btn_site_settings">הגדרות</string>
	<string name="my_site_btn_blog_posts">פוסטים בבלוג</string>
	<string name="reader_label_new_posts_subtitle">יש ללחוץ כדי להציג</string>
	<string name="my_site_header_configuration">הגדרות תצורה</string>
	<string name="notifications_account_required">התחברות לוורדפרס.קום עבור התראות</string>
	<string name="stats_unknown_author">מחבר לא ידוע</string>
	<string name="image_added">תמונה נוספה</string>
	<string name="signout">התנתקות</string>
	<string name="deselect_all">ביטול בחירה בכל האפשרויות</string>
	<string name="hide">הסתר</string>
	<string name="select_all">בחר הכל</string>
	<string name="show">הצג</string>
	<string name="sign_out_wpcom_confirm">ניתוק החשבון יסיר את כל נתוני וורדפרס.קום ‏של %s ממכשיר זה, כולל טיוטות מקומיות ושינויים מקומיים.</string>
	<string name="select_from_new_picker">בחירה מרובה בעזרת רכיב חדש</string>
	<string name="no_media_sources">לא ניתן לטעון קבצי מדיה</string>
	<string name="loading_blog_videos">טוען וידאו</string>
	<string name="loading_blog_images">טוען תמונות</string>
	<string name="error_loading_videos">שגיאה בטעינת וידאו</string>
	<string name="error_loading_images">שגיאה בטעינת תמונות</string>
	<string name="error_loading_blog_images">לא ניתן לטעון תמונות</string>
	<string name="error_loading_blog_videos">לא ניתן לטעון וידאו</string>
	<string name="no_device_images">אין תמונות</string>
	<string name="stats_generic_error">לא ניתן לטעון סטטוס נדרש</string>
	<string name="no_device_videos">אין וידאו</string>
	<string name="no_blog_images">אין תמונות</string>
	<string name="no_blog_videos">אין וידאו</string>
	<string name="loading_videos">טוען וידאו</string>
	<string name="no_media">אין קבצי מדיה</string>
	<string name="loading_images">טוען תמונות</string>
	<string name="editor_toast_invalid_path">נתיב קובץ שגוי</string>
	<string name="verification_code">קוד אימות</string>
	<string name="invalid_verification_code">קוד אימות שגוי</string>
	<string name="verify">אימות</string>
	<string name="two_step_footer_label">יש להזין את הקוד מאפליקציית האימות.</string>
	<string name="two_step_footer_button">שליחת קוד באמצעות הודעת טקסט</string>
	<string name="two_step_sms_sent">יש לבדוק הודעות טקסט לקבלת קוד אימות.</string>
	<string name="error_publish_no_network">לא ניתן לפרסם כאשר אין חיבור אינטרנט. נשמר כטיוטה.</string>
	<string name="auth_required">יש להתחבר שוב כדי המשיך.</string>
	<string name="tab_title_site_videos">וידאו מהאתר</string>
	<string name="tab_title_site_images">תמונות מהאתר</string>
	<string name="tab_title_device_videos">וידאו מהמכשיר</string>
	<string name="tab_title_device_images">תמונות מהמכשיר</string>
	<string name="take_video">צילום וידאו</string>
	<string name="take_photo">צילום תמונה</string>
	<string name="media_picker_title">בחירה</string>
	<string name="add_to_post">הוספה לפוסט</string>
	<string name="language">שפה</string>
	<string name="device">מכשיר</string>
	<string name="sign_in_jetpack">יש להתחבר לחשבון וורדפרס.קום כדי להתחבר אל Jetpack.</string>
	<string name="media_details_label_file_type">סוג קובץ</string>
	<string name="media_details_label_file_name">שם קובץ</string>
	<string name="media_fetching">מביא מדיה...</string>
	<string name="posts_fetching">מביא פוסטים...</string>
	<string name="pages_fetching">מביא עמודים...</string>
	<string name="toast_err_post_uploading">אי אפשר לפתוח פוסט תוך כדי העלאה</string>
	<string name="stats_empty_search_terms">לא נרשמו מונחי חיפוש</string>
	<string name="stats_entry_search_terms">מונח חיפוש</string>
	<string name="stats_view_authors">מחברים</string>
	<string name="stats_view_search_terms">מונחי חיפוש</string>
	<string name="comments_fetching">מביא תגובות...</string>
	<string name="stats_empty_search_terms_desc">ניתן ללמוד עוד על תעבורת החיפוש שלך באמצעות בדיקת המונחים שאותם חיפשו המבקרים כדי למצוא את האתר שלך.</string>
	<string name="stats_followers_total_email_paged">מציג %1$d - %2$d מתוך %3$s עוקבים באימייל</string>
	<string name="stats_search_terms_unknown_search_terms">מונחי חיפוש לא ידועים</string>
	<string name="reader_empty_posts_request_failed">לא הצלחנו לאחזר פוסטים</string>
	<string name="publisher">Publisher:</string>
	<string name="error_notification_open">לא הצלחנו לפתוח את ההתראה</string>
	<string name="stats_followers_total_wpcom_paged">מציג %1$d - %2$d מתוך %3$s עוקבי וורדפרס.קום</string>
	<string name="error_copy_to_clipboard">אירעה שגיאה בעת העתקת הטקסט אל ה-clipboard</string>
	<string name="stats_recent_weeks">שבועות אחרונים</string>
	<string name="logs_copied_to_clipboard">הלוגים של האפליקציה הועתקו אל ה-clipboard</string>
	<string name="stats_overall">מבט כללי</string>
	<string name="stats_period">תקופה</string>
	<string name="reader_empty_posts_in_blog">אתר ריק</string>
	<string name="stats_average_per_day">ממוצע יומי</string>
	<string name="reader_page_recommended_blogs">אתרים שאתה עשוי לאהוב</string>
	<string name="stats_months_and_years">חודשים ושנים</string>
	<string name="reader_label_new_posts">פוסטים חדשים</string>
	<string name="stats_total">סה"כ</string>
	<string name="post_uploading">מעלה</string>
	<string name="stats_comments_total_comments_followers">סה"כ פוסטים עם עוקבים אחר תגובות: %1$s</string>
	<string name="stats_empty_video">לא הופעל וידאו</string>
	<string name="stats_view_videos">וידאו</string>
	<string name="stats_visitors">מבקרים</string>
	<string name="stats_timeframe_years">שנים</string>
	<string name="stats_views">צפיות</string>
	<string name="stats_pagination_label">עמוד %1$s מתוך %2$s</string>
	<string name="stats_likes"> לייקים</string>
	<string name="stats_view_countries">מדינות</string>
	<string name="stats_view_followers">עוקבים</string>
	<string name="stats_view_publicize">שיתוף אוטומטי</string>
	<string name="stats_entry_clicks_link">קישור</string>
	<string name="stats_view_top_posts_and_pages">פוסטים ועמודים</string>
	<string name="stats_totals_publicize">עוקבים</string>
	<string name="stats_entry_followers">עוקב</string>
	<string name="stats_entry_publicize">שירות</string>
	<string name="stats_entry_top_commenter">מחבר</string>
	<string name="stats_entry_video_plays">וידאו</string>
	<string name="stats_empty_geoviews_desc">עיון ברשימה יראה לך אילו מדינות ואזורים מפנים הכי הרבה תעבורה אל האתר שלך.</string>
	<string name="stats_empty_geoviews">לא נרשמו מדינות</string>
	<string name="stats_totals_followers">מאז</string>
	<string name="stats_empty_top_posts_desc">זוהי דרך מצוינת לגלות אילו פריטי תוכן קיבלו הכי הרבה צפיות ולבדוק את הביצועים של פוסטים ועמודים ספציפיים לאורך זמן.</string>
	<string name="stats_empty_top_posts_title">לא נצפו פוסטים או עמודים</string>
	<string name="stats_empty_referrers_title">לא נרשמו הפניות</string>
	<string name="stats_empty_clicks_title">לא נרשמו לחיצות</string>
	<string name="stats_empty_referrers_desc">אפשר לקבל מידע נוסף על הנראות של האתר על ידי בדיקת האתרים ומנועי החיפוש ששולחים אליו הכי הרבה תעבורה</string>
	<string name="stats_empty_tags_and_categories">לא נצפו פוסטים או עמודים מתויגים</string>
	<string name="stats_empty_clicks_desc">אם התוכן שלך כולל קישורים לאתרים אחרים, אפשר לראות על אילו קישורים מבקרי האתר לחצו הכי הרבה.</string>
	<string name="stats_empty_tags_and_categories_desc">אפשר לקבל סקירה כללית על הנושאים הפופולריים ביותר באתר שלך, לפי הפוסטים המובילים מהשבוע שחלף.</string>
	<string name="stats_empty_top_authors_desc">אפשר לעקוב אחר הצפיות בפוסטים של כל משתתף ולהגדיל תמונה כדי לראות את הפריטים הפופולריים ביותר של כל מחבר.</string>
	<string name="stats_empty_comments_desc">אם אפשרת תגובות באתר, אפשר לעקוב אחר המגיבים המובילים ולגלות את פריטי התוכן שהציתו את השיחות התוססות ביותר, על פי 1,000 התגובות האחרונות.</string>
	<string name="stats_empty_video_desc">לאחר העלאת סרטוני וידאו בעזרת VideoPress אפשר לקבל פרטים על מספר הצפיות.</string>
	<string name="stats_empty_publicize">לא נרשמו עוקבים בשיתוף האוטומטי</string>
	<string name="stats_empty_followers">אין עוקבים</string>
	<string name="stats_empty_publicize_desc">בעזרת שיתוף אוטומטי אפשר לנהל מעקב אחר העוקבים שלך מרשתות חברתיות שונות.</string>
	<string name="stats_empty_followers_desc">אפשר לעקוב אחר המספר הכולל של עוקבים ומשך הזמן שכל אחד מהם עוקב אחר האתר שלך.</string>
	<string name="stats_comments_by_posts_and_pages">לפי פוסטים ועמודים</string>
	<string name="stats_comments_by_authors">לפי מחברים</string>
	<string name="stats_followers_email_selector">אימייל</string>
	<string name="stats_followers_wpcom_selector">WordPress.com</string>
	<string name="stats_followers_seconds_ago">לפני כמה שניות</string>
	<string name="stats_followers_total_email">סה"כ עוקבי אימייל: %1$s</string>
	<string name="stats_followers_days">%1$d ימים</string>
	<string name="stats_followers_a_minute_ago">לפני דקה</string>
	<string name="stats_followers_hours">%1$d שעות</string>
	<string name="stats_followers_a_day">יום</string>
	<string name="stats_followers_minutes">%1$d דקות</string>
	<string name="stats_followers_an_hour_ago">לפני שעה</string>
	<string name="stats_followers_years">%1$d שנים</string>
	<string name="stats_followers_a_month">חודש</string>
	<string name="stats_followers_months">%1$d חודשים</string>
	<string name="stats_followers_a_year">שנה</string>
	<string name="stats_view_all">להציג הכל</string>
	<string name="stats_view">הצגה</string>
	<string name="themes_fetching">משיג ערכות עיצוב…</string>
	<string name="stats_for">סטטיסטיקות עבור %s</string>
	<string name="stats_other_recent_stats_label">סטטיסטיקות אחרות מהזמן האחרון</string>
	<string name="stats_followers_total_wpcom">סה"כ עוקבי וורדפרס.קום: %1$s</string>
	<string name="ssl_certificate_details">פרטים</string>
	<string name="media_gallery_date_range">הצגת פריטי מדיה מ- %1$s עד %2$s</string>
	<string name="confirm_delete_media">מחיקת פריט שנבחר?</string>
	<string name="confirm_delete_multi_media">מחיקת פריטים שנבחרו?</string>
	<string name="cab_selected">%d נבחרו</string>
	<string name="sure_to_remove_account">הסרת אתר?</string>
	<string name="delete_sure_page">מחיקת עמוד</string>
	<string name="delete_sure_post">מחיקת פוסט</string>
	<string name="delete_sure">מחיקת טיוטה</string>
	<string name="stats_no_blog">לא ניתן לטעון את הנתונים הסטטיסטיים עבור האתר הדרוש</string>
	<string name="faq_button">שאלות נפוצות</string>
	<string name="reader_empty_comments">אין תגובות עדיין</string>
	<string name="reader_empty_posts_in_tag">אין פוסטים עם התגית הזו</string>
	<string name="reader_label_comment_count_multi">%,d תגובות</string>
	<string name="reader_label_view_original">לצפות בפוסט המקורי</string>
	<string name="reader_label_comment_count_single">תגובה אחת</string>
	<string name="reader_label_comments_on">תגובות מופעלות</string>
	<string name="reader_label_comments_closed">תגובות לא מופעלות</string>
	<string name="error_publish_empty_post">לא ניתן לפרסם פוסט ריק</string>
	<string name="more">עוד</string>
	<string name="error_refresh_unauthorized_pages">אין לך הרשאה לערוך או לצפות בעמודים</string>
	<string name="error_refresh_unauthorized_posts">אין לך הרשאה לערוך או לצפות בפוסטים</string>
	<string name="reader_title_photo_viewer">%1$d מתוך %2$d</string>
	<string name="comment">תגובה</string>
	<string name="comment_trashed">התגובה הועברה לפח</string>
	<string name="posts_empty_list">אין פוסטים עדיין. למה לא ליצור אחד?</string>
	<string name="comment_reply_to_user">להגיב ל-%s</string>
	<string name="pages_empty_list">אין עמודים עדיין. למה לא ליצור אחד?</string>
	<string name="reader_empty_posts_liked">לא עשית לייק על אף פוסט</string>
	<string name="browse_our_faq_button">לעיון בשאלות הנפוצות שלנו</string>
	<string name="nux_help_description">אפשר לבקר במרכז העזרה כדי לקבל תשובות לשאלות נפוצות, או לבקר בפורומים כדי לשאול שאלות חדשות</string>
	<string name="reader_label_like">לייק</string>
	<string name="error_refresh_unauthorized_comments">איך לך הרשאה להציג או לערוך תגובות</string>
	<string name="older_month">בן יותר מחודש</string>
	<string name="older_two_days">בן יותר מיומיים</string>
	<string name="older_last_week">בן יותר משבוע</string>
	<string name="select_a_blog">בחר אתר WordPress</string>
	<string name="uploading_total">העלאה %1$d של %2$d</string>
	<string name="mnu_comment_liked">פרסם לייק</string>
	<string name="media_empty_list_custom_date">אין מדיה במרווח זמן זה</string>
	<string name="posting_post">מפרסם "%s"</string>
	<string name="signing_out">יוצא מהמערכת...</string>
	<string name="agree_terms_of_service">‏יצירת חשבון מהווה הסכמה ל%1$sתנאי השימוש המרתקים%2$s שלנו</string>
	<string name="sending_content">מעלה תוכן של %s</string>
	<string name="create_new_blog_wpcom">יצירת אתר וורדפרס.קום</string>
	<string name="new_blog_wpcom_created">נוצר אתר בוורדפרס.קום</string>
	<string name="reader_empty_followed_blogs_title">אינך עוקב אחרי שום אתר עדיין</string>
	<string name="reader_menu_block_blog">לחסום את האתר הזה</string>
	<string name="reader_toast_blog_blocked">הפוסטים מהאתר הזה לא יוצגו עוד</string>
	<string name="reader_toast_err_block_blog">לא ניתן לחסום אתר זה</string>
	<string name="reader_toast_err_generic">לא ניתן לבצע את הפעולה</string>
	<string name="contact_us">ליצור קשר</string>
	<string name="hs__conversation_detail_error">תאר/י את הבעיה בה נתקלת</string>
	<string name="hs__new_conversation_header">צ׳אט תמיכה</string>
	<string name="hs__conversation_header">צ׳אט תמיכה</string>
	<string name="hs__username_blank_error">נא להזין שם</string>
	<string name="hs__invalid_email_error">נא להזין כתובת אימייל</string>
	<string name="add_location">הוספת מיקום</string>
	<string name="current_location">מיקום נוכחי</string>
	<string name="search_location">חיפוש</string>
	<string name="edit_location">עריכה</string>
	<string name="search_current_location">אתר</string>
	<string name="preference_send_usage_stats">שליחת סטטיסטיקות</string>
	<string name="preference_send_usage_stats_summary">שליחת נתוני שימוש סטטיסטיים שיאפשרו לנו לשפר את WordPress לאנדרויד</string>
	<string name="update_verb">עדכן</string>
	<string name="schedule_verb">תזמן</string>
	<string name="reader_toast_err_unfollow_blog">לא ניתן לבטל את המעקב אחר אתר זה</string>
	<string name="reader_empty_recommended_blogs">אין אתרים מומלצים</string>
	<string name="reader_toast_err_follow_blog">לא ניתן לעקוב אחר אתר זה</string>
	<string name="reader_toast_err_already_follow_blog">אתה כבר עוקב אחר אתר זה</string>
	<string name="reader_toast_err_get_blog_info">לא ניתן להציג אתר זה</string>
	<string name="reader_label_followed_blog">אתר נעקב</string>
	<string name="reader_title_subs">תגיות ואתרים</string>
	<string name="reader_page_followed_blogs">אתרים נעקבים</string>
	<string name="reader_page_followed_tags">תגיות נעקבות</string>
	<string name="reader_hint_add_tag_or_url">הזן תגית או כתובת אתר למעקב</string>
	<string name="reader_label_tag_preview">פוסטים שתויגו %s</string>
	<string name="reader_title_blog_preview">קורא בלוג</string>
	<string name="reader_title_tag_preview">קורא תגית</string>
	<string name="saving">שומר...</string>
	<string name="media_empty_list">אין מדיה</string>
	<string name="ptr_tip_message">עצה: משוך כלפי מטה כדי לרענן</string>
	<string name="help">עזרה</string>
	<string name="forgot_password">איבדת את הסיסמה שלך?</string>
	<string name="forums">פורומים</string>
	<string name="help_center">מרכז עזרה</string>
	<string name="ssl_certificate_error">אישור SSL לא תקף</string>
	<string name="ssl_certificate_ask_trust">אם בדרך כלל אתה מתחבר לאתר זה ללא בעיות, ייתכן ששגיאה זו נובעת מכך שמישהו מנסה להתחזות לאתר ולכן אסור לך להמשיך. האם ברצונך בכל זאת לתת אמון באישור?</string>
	<string name="blog_not_found">אירעה שגיאה בזמן הגישה לאתר זה</string>
	<string name="could_not_remove_account">לא ניתן היה להסיר את האתר</string>
	<string name="out_of_memory">זיכרון המכשיר מלא</string>
	<string name="no_network_message">אין רשת זמינה</string>
	<string name="gallery_error">לא ניתן היה לאחזר את פריט המדיה</string>
	<string name="wait_until_upload_completes">המתן לסיום ההעלאה</string>
	<string name="theme_fetch_failed">הבאת ערכות העיצוב נכשלה</string>
	<string name="theme_set_failed">הגדרת ערכת העיצוב נכשלה</string>
	<string name="theme_auth_error_message">ודא שיש לך הרשאה להגדיר ערכות עיצוב</string>
	<string name="comments_empty_list">אין תגובות</string>
	<string name="mnu_comment_unspam">לא תגובת זבל</string>
	<string name="no_site_error">לא ניתן היה להתחבר לאתר WordPress</string>
	<string name="adding_cat_failed">הוספת קטגוריה נכשלה</string>
	<string name="adding_cat_success">הקטגוריה הוספה בהצלחה</string>
	<string name="cat_name_required">שם הקטגוריה הוא שדה חובה</string>
	<string name="category_automatically_renamed">שם הקטגוריה %1$s אינו תקף. הוא שונה ל-%2$s.</string>
	<string name="no_account">לא נמצא חשבון ב-WordPress, הוסף חשבון ונסה שנית</string>
	<string name="sdcard_message">יש לטעון כרטיס SD כדי להעלות קבצים</string>
	<string name="stats_empty_comments">עדיין אין תגובות</string>
	<string name="stats_bar_graph_empty">הנתונים הסטטיסטיים לא זמינים</string>
	<string name="reply_failed">התשובה נכשלה</string>
	<string name="notifications_empty_list">אין הודעות</string>
	<string name="error_delete_post">אירעה שגיאה בזמן המחיקה של %s</string>
	<string name="error_refresh_posts">לא ניתן לרענן רשומות כעת</string>
	<string name="error_refresh_pages">לא ניתן לרענן דפים כעת</string>
	<string name="error_refresh_notifications">לא ניתן לרענן הודעות כעת</string>
	<string name="error_refresh_comments">לא ניתן לרענן תגובות כעת</string>
	<string name="error_refresh_stats">לא ניתן לרענן נתונים סטטיסטיים כעת</string>
	<string name="error_generic">אירעה שגיאה</string>
	<string name="error_moderate_comment">אירעה שגיאה בזמן בדיקת התגובות</string>
	<string name="error_edit_comment">אירעה שגיאה בזמן עריכת התגובה</string>
	<string name="error_upload">אירעה שגיאה בזמן העלאת ה-%s</string>
	<string name="error_load_comment">לא ניתן היה להעלות את התגובה</string>
	<string name="error_downloading_image">שגיאה בזמן הורדת תמונה</string>
	<string name="passcode_wrong_passcode">PIN שגוי</string>
	<string name="invalid_email_message">כתובת האימייל שלך לא תקפה</string>
	<string name="invalid_password_message">הסיסמה חייבת להכיל לפחות 4 תווים</string>
	<string name="invalid_username_too_short">שם המשתמש חייב להכיל מעל 4 תווים</string>
	<string name="invalid_username_too_long">שם המשתמש חייב להכיל פחות מ-61 תווים</string>
	<string name="username_only_lowercase_letters_and_numbers">שם משתמש יכול להכיל רק אותיות לא רישיות (a-z) וספרות</string>
	<string name="username_required">הקלד שם משתמש</string>
	<string name="username_not_allowed">שם המשתמש לא מותר</string>
	<string name="username_must_be_at_least_four_characters">שם המשתמש חייב להכיל לפחות 4 תווים</string>
	<string name="username_contains_invalid_characters">שם המשתמש לא יכול לכלול את התו "_"</string>
	<string name="username_must_include_letters">שם המשתמש חייב לכלול לפחות אות אחת (a-z)</string>
	<string name="email_invalid">הקלד כתובת אימייל חוקית</string>
	<string name="email_not_allowed">כתובת אימייל זו אינה מותרת</string>
	<string name="username_exists">שם משתמש זה כבר קיים</string>
	<string name="email_exists">כתובת אימייל זו כבר בשימוש</string>
	<string name="username_reserved_but_may_be_available">שם המשתמש הזה שמור כעת אך עשוי להיות זמין בעוד כמה ימים</string>
	<string name="blog_name_required">הזן כתובת אתר</string>
	<string name="blog_name_not_allowed">כתובת אתר זו אינה מותרת</string>
	<string name="blog_name_must_be_at_least_four_characters">כתובת האתר חייבת להכיל לפחות 4 תווים</string>
	<string name="blog_name_must_be_less_than_sixty_four_characters">כתובת האתר חייבת לכלול פחות מ-64 תווים</string>
	<string name="blog_name_contains_invalid_characters">כתובת האתר לא יכולה לכלול את התו "_"</string>
	<string name="blog_name_cant_be_used">אינך רשאי להשתמש בכתובת אתר זו</string>
	<string name="blog_name_only_lowercase_letters_and_numbers">כתובת האתר יכולה לכלול רק אותיות לא רישיות (a-z) וספרות</string>
	<string name="blog_name_exists">אתר זה כבר קיים</string>
	<string name="blog_name_reserved">אתר זה שמור</string>
	<string name="blog_name_reserved_but_may_be_available">אתר זה שמור כעת אך עשוי להיות זמין בעוד כמה ימים</string>
	<string name="username_or_password_incorrect">שם המשתמש או הסיסמה שהקלדת שגויים</string>
	<string name="nux_cannot_log_in">איננו יכולים לחבר אותך</string>
	<string name="invalid_url_message">ודא שכתובת האתר שהוזנה תקפה</string>
	<string name="wordpress_blog">אתר ב-WordPress</string>
	<string name="blog_removed_successfully">האתר הוסר בהצלחה</string>
	<string name="add_account_blog_url">כתובת האתר</string>
	<string name="remove_account">הסר אתר</string>
	<string name="error_blog_hidden">זה אתר סמוי ולא ניתן לטעון אותו. אפשר אותו שוב בהגדרות ונסה שנית.</string>
	<string name="xmlrpc_error">לא ניתן להתחבר. הקלד את הנתיב המלא אל xmlrpc.php באתר שלך ונסה שנית.</string>
	<string name="select_categories">בחר קטגוריות</string>
	<string name="account_details">פרטי חשבון</string>
	<string name="edit_post">ערוך רשומה</string>
	<string name="add_comment">הוסף תגובה</string>
	<string name="connection_error">שגיאת התחברות</string>
	<string name="cancel_edit">בטל עריכה</string>
	<string name="scaled_image_error">הקלד ערך תקף של רוחב מדורג</string>
	<string name="post_not_found">אירעה שגיאה בזמן העלאת הרשומה. רענן את הרשומות שלך ונסה שנית.</string>
	<string name="learn_more">מידע נוסף</string>
	<string name="media_gallery_settings_title">הגדרות גלריה</string>
	<string name="media_gallery_image_order">סדר התמונות</string>
	<string name="media_gallery_num_columns">מספר העמודות</string>
	<string name="media_gallery_type_thumbnail_grid">טבלת תמונות ממוזערות</string>
	<string name="media_gallery_edit">ערוך גלריה</string>
	<string name="media_error_no_permission">אין לך הרשאה לצפות בספריית המדיה</string>
	<string name="cannot_delete_multi_media_items">לא ניתן בשלב זה למחוק חלק מהמדיה. נסה שנית מאוחר יותר.</string>
	<string name="themes_live_preview">תצוגה מקדימה חיה</string>
	<string name="theme_current_theme">ערכת עיצוב נוכחית</string>
	<string name="theme_premium_theme">ערכת עיצוב מסוג Premium Theme </string>
	<string name="link_enter_url_text">טקסט קישור (אופציונאלי)</string>
	<string name="create_a_link">צור קישור</string>
	<string name="page_settings">הגדרות דף</string>
	<string name="local_draft">טיוטה מקומית</string>
	<string name="upload_failed">העלאה נכשלה</string>
	<string name="horizontal_alignment">יישור אופקי</string>
	<string name="file_not_found">מציאת הקובץ להעלאה נכשלה. האם הוא נמחק או הועבר?</string>
	<string name="post_settings">הגדרות רשומה</string>
	<string name="delete_post">מחק רשומה</string>
	<string name="delete_page">מחק דף</string>
	<string name="comment_status_approved">אושר</string>
	<string name="comment_status_unapproved">בהמתנה</string>
	<string name="comment_status_spam">תגובות זבל</string>
	<string name="comment_status_trash">הושלך לאשפה</string>
	<string name="edit_comment">ערוך תגובה</string>
	<string name="mnu_comment_approve">אשר</string>
	<string name="mnu_comment_unapprove">בטל אישור</string>
	<string name="mnu_comment_spam">תגובות זבל</string>
	<string name="mnu_comment_trash">אשפה</string>
	<string name="dlg_approving_comments">מאשר</string>
	<string name="dlg_unapproving_comments">מבטל אישור</string>
	<string name="dlg_spamming_comments">מסמן כתגובת זבל</string>
	<string name="dlg_trashing_comments">שולח לאשפה</string>
	<string name="dlg_confirm_trash_comments">לשלוח לאשפה?</string>
	<string name="trash_yes">אשפה</string>
	<string name="trash_no">לא לשלוח לאשפה</string>
	<string name="trash">אשפה</string>
	<string name="author_name">שם המחבר</string>
	<string name="author_email">אימייל של המחבר</string>
	<string name="author_url">כתובת URL של המחבר </string>
	<string name="hint_comment_content">תגובה</string>
	<string name="saving_changes">שומר שינויים</string>
	<string name="sure_to_cancel_edit_comment">לבטל עריכה של תגובה זו?</string>
	<string name="content_required">נדרשת תגובה</string>
	<string name="toast_comment_unedited">התגובה לא השתנתה</string>
	<string name="delete_draft">מחק טיוטה</string>
	<string name="preview_page">תצוגה מקדימה של הדף</string>
	<string name="preview_post">תצוגה מקדימה של הרשומה</string>
	<string name="comment_added">התגובה הוספה בהצלחה</string>
	<string name="post_not_published">מצב העריכה לא פורסם</string>
	<string name="page_not_published">מצב הדף לא פורסם</string>
	<string name="view_in_browser">הצג בדפדפן</string>
	<string name="add_new_category">הוסף קטגוריה חדשה</string>
	<string name="category_name">שם קטגוריה</string>
	<string name="category_slug">מזהה לכתובת קטגוריה (אופציונאלי)</string>
	<string name="category_desc">תיאור קטגוריה (אופציונאלי)</string>
	<string name="category_parent">קטגוריית-אב (אופציונאלי):</string>
	<string name="share_action_post">רשומה חדשה</string>
	<string name="share_action_media">ספריית מדיה</string>
	<string name="file_error_create">יצירת קובץ temp להעלאת קבצים לא הצליחה. וודא שיש מספיק מקום פנוי במכשיר.</string>
	<string name="location_not_found">מיקום לא ידוע</string>
	<string name="open_source_licenses">רישיונות קוד פתוח</string>
	<string name="pending_review">בהמתנה לבדיקה</string>
	<string name="http_credentials">אישורי HTTP (אופציונאלי)</string>
	<string name="http_authorization_required">דרושה הרשאה</string>
	<string name="post_format">סוג רשומה</string>
	<string name="new_post">רשומה חדשה</string>
	<string name="new_media">מדיה חדשה</string>
	<string name="view_site">צפה באתר</string>
	<string name="privacy_policy">מדיניות פרטיות</string>
	<string name="local_changes">שינויים מקומיים</string>
	<string name="image_settings">הגדרות תמונה</string>
	<string name="fatal_db_error">אירעה שגיאה בזמן יצירת מסד הנתונים של היישום. נסה להתקין מחדש את היישום.</string>
	<string name="jetpack_message_not_admin">התוסף Jetpack נדרש לקבלת נתונים סטטיסטיים. פנה למנהל האתר.</string>
	<string name="reader_title_applog">יומן יישום</string>
	<string name="reader_share_link">שתף בקישור</string>
	<string name="reader_toast_err_add_tag">לא ניתן להוסיף תגית זו</string>
	<string name="reader_toast_err_remove_tag">לא ניתן להסיר תגית זו</string>
	<string name="required_field">שדה חובה</string>
	<string name="email_hint">כתובת אימייל</string>
	<string name="site_address">כתובת האחסון העצמי שלך (URL)</string>
	<string name="email_cant_be_used_to_signup">אינך רשאי להשתמש בכתובת אימייל זו בהרשמה. יש לנו בעיה מכיוון שהם חוסמים חלק מהודעות האימייל שלנו. השתמש בספק אימייל אחר.</string>
	<string name="email_reserved">כתובת אימייל זו כבר הייתה בשימוש. חפש בתיבת הדואר הנכנס שלך אימייל להפעלה. אם לא תפעיל עכשיו תוכל לנסות שנית בעוד כמה ימים.</string>
	<string name="blog_name_must_include_letters">כתובת האתר חייב לכלול לפחות אות אחת (a-z)</string>
	<string name="blog_name_invalid">כתובת אתר לא תקפה</string>
	<string name="blog_title_invalid">כותרת אתר לא תקפה</string>
	<string name="notifications_empty_all">אין התראות... עדיין.</string>
	<string name="invalid_site_url_message">יש לוודא שכתובת ה-URL של האתר שהוזנה תקפה</string>
	<string name="share_url_post">שתף פוסט</string>
	<string name="share_url_page">שתף עמוד</string>
	<string name="share_link">קישור לשיתוף</string>
	<string name="deleting_page">מוחק דף</string>
	<string name="deleting_post">מוחק רשומה</string>
	<string name="creating_your_account">יוצר את החשבון שלך</string>
	<string name="creating_your_site">יוצר את האתר שלך</string>
	<string name="reader_empty_posts_in_tag_updating">מביא רשומות...</string>
	<string name="error_refresh_media">משהו השתבש בזמן הרענון של ספריית המדיה. נסה שנית מאוחר יותר.</string>
	<string name="cant_share_no_visible_blog">אינך יכול לשתף ב-WordPress ללא אתר גלוי</string>
	<string name="reader_likes_you_and_multi">אתה ו- %,d אחרים אוהבים את זה</string>
	<string name="reader_likes_multi">%,d אנשים אוהבים את זה</string>
	<string name="reader_toast_err_get_comment">לא ניתן לאחזר תגובה זו</string>
	<string name="reader_label_reply">תשובה</string>
	<string name="video">וידאו</string>
	<string name="download">מוריד מדיה</string>
	<string name="comment_spammed">התגובה סומנה כתגובת זבל</string>
	<string name="select_time">בחר שעה</string>
	<string name="reader_likes_you_and_one">אתה ועוד אחד אוהבים את זה</string>
	<string name="select_date">בחר תאריך</string>
	<string name="pick_photo">בחר תמונה</string>
	<string name="pick_video">בחר וידאו</string>
	<string name="reader_toast_err_get_post">לא ניתן לאחזר רשומה זו</string>
	<string name="validating_user_data">מאמת נתוני משתמש</string>
	<string name="validating_site_data">מאמת נתוני אתר</string>
	<string name="account_two_step_auth_enabled">בחשבון זה מופעל אימות דו-שלבי. עיין בהגדרות האבטחה בוורדפרס.קום וצור סיסמה ספציפית ליישום.</string>
	<string name="reader_empty_followed_blogs_description">אך אין צורך לדאוג, יש להקיש מימין כדי להתחיל לשוטט!</string>
	<string name="password_invalid">נחוצה לך סיסמה בטוחה יותר. הקפד להשתמש ב-7 תווים או יותר, שלב אותיות רישיות ורגילות, מספרים או תווים מיוחדים.</string>
	<string name="nux_tap_continue">המשך</string>
	<string name="nux_welcome_create_account">צור חשבון</string>
	<string name="nux_add_selfhosted_blog">הוסף אתר באחסון עצמי</string>
	<string name="signing_in">מתחבר...</string>
	<string name="nux_oops_not_selfhosted_blog">התחבר לוורדפרס.קום</string>
	<string name="media_add_popup_title">הוסף לספריית המדיה</string>
	<string name="media_add_new_media_gallery">צור גלרייה</string>
	<string name="empty_list_default">רשימה זו ריקה</string>
	<string name="select_from_media_library">בחר מתוך ספריית מדיה</string>
	<string name="jetpack_message">התוסף Jetpack נדרש לקבלת נתונים סטטיסטיים. אתה מעוניין להתקין את Jetpack?</string>
	<string name="jetpack_not_found">התוסף Jetpack לא נמצא</string>
	<string name="reader_untitled_post">(ללא כותרת)</string>
	<string name="reader_share_subject">שיתוף מ-%s</string>
	<string name="reader_btn_share">שתף</string>
	<string name="reader_btn_follow">עקוב</string>
	<string name="reader_btn_unfollow">עוקב</string>
	<string name="reader_hint_comment_on_comment">השב לתגובה</string>
	<string name="reader_label_added_tag">%s התווסף</string>
	<string name="reader_label_removed_tag">%s הוסר</string>
	<string name="reader_likes_one">אדם אחד אוהב את זה</string>
	<string name="reader_likes_only_you">אתה אוהב את זה</string>
	<string name="reader_toast_err_comment_failed">לא ניתן לפרסם את תגובתך</string>
	<string name="reader_toast_err_tag_exists">אתה כבר עוקב אחר תגית זו</string>
	<string name="reader_toast_err_tag_invalid">זו לא תגית תקפה</string>
	<string name="reader_toast_err_share_intent">לא ניתן לשתף</string>
	<string name="reader_toast_err_view_image">לא ניתן להציג תמונה</string>
	<string name="reader_toast_err_url_intent">לא ניתן לפתוח את %s</string>
	<string name="username_invalid">שם משתמש לא חוקי</string>
	<string name="limit_reached">הגעת למגבלה. תוכל לנסות שנית בעוד דקה 1. אם תנסה שנית קודם לכן, זה רק יאריך את זמן ההמתנה שלך עד להסרת המגבלה. אם אתה חושב שזו שגיאה, פנה לתמיכה.</string>
	<string name="nux_tutorial_get_started_title">צא לדרך!</string>
	<string name="reader_empty_followed_tags">אין מעקב אחר שום תגית</string>
	<string name="create_account_wpcom">יצירת חשבון וורדפרס.קום</string>
	<string name="connecting_wpcom">מתחבר לוורדפרס.קום</string>
	<string name="button_next">לשלב הבא</string>
	<string name="themes">ערכות עיצוב</string>
	<string name="all">הכל</string>
	<string name="images">תמונות</string>
	<string name="media_gallery_image_order_random">אקראי</string>
	<string name="stats_view_tags_and_categories">תגים וקטגוריות</string>
	<string name="unattached">מנותק</string>
	<string name="custom_date">תאריך מותאם אישית</string>
	<string name="media_add_popup_capture_photo">צלם תמונה</string>
	<string name="media_add_popup_capture_video">צלם וידאו</string>
	<string name="media_gallery_image_order_reverse">אחורה</string>
	<string name="media_gallery_type">סוג</string>
	<string name="media_gallery_type_squares">ריבועים</string>
	<string name="media_gallery_type_tiled">אריחים</string>
	<string name="media_gallery_type_circles">עיגולים</string>
	<string name="media_gallery_type_slideshow">מצגת</string>
	<string name="media_edit_title_text">כותרת</string>
	<string name="media_edit_caption_text">כיתוב</string>
	<string name="media_edit_description_text">תיאור</string>
	<string name="media_edit_title_hint">הקלד כותרת כאן</string>
	<string name="media_edit_caption_hint">הקלד כיתוב כאן</string>
	<string name="media_edit_description_hint">הקלד תיאור כאן</string>
	<string name="media_edit_success">עודכן</string>
	<string name="media_edit_failure">עדכון נכשל</string>
	<string name="themes_details_label">פרטים</string>
	<string name="themes_features_label">תכונות</string>
	<string name="theme_activate_button">הפעל</string>
	<string name="theme_activating_button">מפעיל</string>
	<string name="theme_set_success">ערכת העיצוב הוגדרה בהצלחה!</string>
	<string name="theme_auth_error_title">הבאת ערכות העיצוב נכשלה</string>
	<string name="post_excerpt">תקציר</string>
	<string name="share_action_title">הוסף ל...</string>
	<string name="share_action">שתף</string>
	<string name="stats">נתונים סטטיסטיים</string>
	<string name="stats_view_visitors_and_views">מבקרים וצפיות</string>
	<string name="stats_view_clicks">קליקים</string>
	<string name="stats_view_referrers">הפניות</string>
	<string name="stats_timeframe_today">היום</string>
	<string name="stats_timeframe_yesterday">אתמול</string>
	<string name="stats_timeframe_days">ימים</string>
	<string name="stats_timeframe_weeks">שבועות</string>
	<string name="stats_timeframe_months">חודשים</string>
	<string name="stats_entry_country">ארץ</string>
	<string name="stats_entry_posts_and_pages">כותרת</string>
	<string name="stats_entry_tags_and_categories">נושא</string>
	<string name="stats_entry_authors">מחבר</string>
	<string name="stats_entry_referrers">הפניה</string>
	<string name="stats_totals_views">צפיות</string>
	<string name="stats_totals_clicks">קליקים</string>
	<string name="stats_totals_plays">ניגונים</string>
	<string name="passcode_manage">ניהול חסימה בקוד אישי</string>
	<string name="passcode_enter_passcode">הקלד את הקוד האישי שלך</string>
	<string name="passcode_enter_old_passcode">הקלד את הקוד האישי הישן שלך</string>
	<string name="passcode_re_enter_passcode">הקלד שנית את הקוד האישי שלך</string>
	<string name="passcode_change_passcode">החלף את הקוד האישי שלך</string>
	<string name="passcode_set">קוד אישי הוגדר</string>
	<string name="passcode_preference_title">נעילת קוד אישי</string>
	<string name="passcode_turn_off">הפסק נעילת קוד אישי</string>
	<string name="passcode_turn_on">הפעל נעילת קוד אישי</string>
	<string name="discard">הסתר</string>
	<string name="upload">העלאה</string>
	<string name="sign_in">התחבר</string>
	<string name="notifications">התראות</string>
	<string name="note_reply_successful">תגובה פורסמה</string>
	<string name="new_notifications">%d התראות חדשות</string>
	<string name="more_notifications">הוסף %d נוספים.</string>
	<string name="follows">עוקבים</string>
	<string name="loading">טוען...</string>
	<string name="httpuser">שם משתמש</string>
	<string name="httppassword">סיסמה</string>
	<string name="error_media_upload">ארעה שגיאה במהלך העלאת הקובץ.</string>
	<string name="publish_date">פרסם</string>
	<string name="content_description_add_media">הוסף מדיה</string>
	<string name="post_content">תוכן (הקליקו להוספת טקסט או קבצי מדיה)</string>
	<string name="incorrect_credentials">שם משתמש או סיסמה לא נכונים.</string>
	<string name="password">סיסמה</string>
	<string name="username">שם משתמש</string>
	<string name="reader">קורא</string>
	<string name="width">רוחב</string>
	<string name="posts">פוסטים</string>
	<string name="pages">עמודים</string>
	<string name="post">פוסט</string>
	<string name="page">עמוד</string>
	<string name="anonymous">אנונימי</string>
	<string name="featured">תמונה מובחרת</string>
	<string name="no_network_title">הרשת אינה זמינה</string>
	<string name="caption">כיתוב תמונה (אופציונלי)</string>
	<string name="featured_in_post">הוספת תמונה לתוכן</string>
	<string name="ok">אוקיי</string>
	<string name="blogusername">שם משתמש</string>
	<string name="scaled_image">רוחב תמונה</string>
	<string name="upload_scaled_image">העלאה וקישור לתמונה</string>
	<string name="scheduled">תוזמן</string>
	<string name="link_enter_url">URL</string>
	<string name="uploading">מעלה...</string>
	<string name="version">גרסה</string>
	<string name="tos">תנאי שימוש</string>
	<string name="app_title">וורדפרס עבור אנדרואיד</string>
	<string name="max_thumbnail_px_width">ברירת מחדל לרוחב תמונה</string>
	<string name="image_alignment">יישור</string>
	<string name="refresh">רענון</string>
	<string name="untitled">ללא כותרת</string>
	<string name="edit">עריכה</string>
	<string name="post_id">פוסט</string>
	<string name="page_id">עמוד</string>
	<string name="immediately">מיד</string>
	<string name="post_password">ססמה (לא חובה)</string>
	<string name="quickpress_add_alert_title">קבע שם מקוצר</string>
	<string name="today">היום</string>
	<string name="settings">הגדרות</string>
	<string name="share_url">שתף כתובת קבועה</string>
	<string name="quickpress_window_title">בחר אתר לקיצור דרך  קוויקפרס</string>
	<string name="quickpress_add_error">שם קיצור הדרך אינו יכול להיות ריק</string>
	<string name="publish_post">פרסם</string>
	<string name="draft">טיוטה</string>
	<string name="post_private">פרטי</string>
	<string name="upload_full_size_image">העלה וקשה לתמונה בגודל מלא</string>
	<string name="categories">קטגוריות</string>
	<string name="tags_separate_with_commas">תגים (יש להפריד בפסיקים)</string>
	<string name="title">כותרת</string>
	<string name="dlg_deleting_comments">מוחק תגובות</string>
	<string name="notification_vibrate">רטט</string>
	<string name="notification_blink">האר נורית הודעה</string>
	<string name="notification_sound">צליל התראה</string>
	<string name="status">סטטוס</string>
	<string name="location">מיקום</string>
	<string name="sdcard_title">דרוש כרטיס SD</string>
	<string name="select_video">בחר וידאו מהגלריה</string>
	<string name="media">מדיה</string>
	<string name="delete">מחק</string>
	<string name="none">ללא</string>
	<string name="blogs">אתרים</string>
	<string name="select_photo">בחר תמונה מהגלריה</string>
	<string name="yes">כן</string>
	<string name="no">לא</string>
	<string name="add">הוסף</string>
	<string name="save">שמור</string>
	<string name="cancel">בטל</string>
	<string name="error">שגיאה</string>
	<string name="on">ב</string>
	<string name="category_refresh_error">שגיאה ברענון קטגוריות</string>
	<string name="reply">תגובה</string>
	<string name="preview">תצוגה מקדימה</string>
	<string name="notification_settings">הגדרות התראות</string>
</resources>
