<?xml version="1.0" encoding="utf-8"?>
<resources>
	<string name="role_admin">Administrator</string>
	<string name="role_editor">Editor</string>
	<string name="role_author">Author</string>
	<string name="role_contributor">Contributor</string>
	<string name="role_follower">Follower</string>
	<string name="role_viewer">Viewer</string>
	<string name="error_post_my_profile_no_connection">No connection, couldn\'t save your profile</string>
	<string name="alignment_none">None</string>
	<string name="alignment_left">Left</string>
	<string name="alignment_right">Right</string>
	<string name="site_settings_list_editor_action_mode_title">Selected %1$d</string>
	<string name="error_fetch_users_list">Couldn\'t retrieve site users</string>
	<string name="plans_manage">Manage your plan at\nWordPress.com/plans</string>
	<string name="people_empty_list_filtered_viewers">You don\'t have any viewers yet.</string>
	<string name="people_fetching">Fetching users…</string>
	<string name="title_follower">Follower</string>
	<string name="title_email_follower">Email Follower</string>
	<string name="people_empty_list_filtered_email_followers">You don\'t have any email followers yet.</string>
	<string name="people_empty_list_filtered_followers">You don\'t have any followers yet.</string>
	<string name="people_empty_list_filtered_users">You don\'t have any users yet.</string>
	<string name="people_dropdown_item_email_followers">Email Followers</string>
	<string name="people_dropdown_item_viewers">Viewers</string>
	<string name="people_dropdown_item_followers">Followers</string>
	<string name="people_dropdown_item_team">Team</string>
	<string name="invite_message_usernames_limit">Invite up to 10 email addresses and/or WordPress.com usernames. Those needing a username will be sent instructions on how to create one.</string>
	<string name="viewer_remove_confirmation_message">If you remove this viewer, he or she will not be able to visit this site.\n\nWould you still like to remove this viewer?</string>
	<string name="follower_remove_confirmation_message">If removed, this follower will stop receiving notifications about this site, unless they re-follow.\n\nWould you still like to remove this follower?</string>
	<string name="follower_subscribed_since">Since %1$s</string>
	<string name="reader_label_view_gallery">View Gallery</string>
	<string name="error_remove_follower">Couldn\'t remove follower</string>
	<string name="error_remove_viewer">Couldn\'t remove viewer</string>
	<string name="error_fetch_email_followers_list">Couldn\'t retrieve site email followers</string>
	<string name="error_fetch_followers_list">Couldn\'t retrieve site followers</string>
	<string name="editor_failed_uploads_switch_html">Some media uploads have failed. You can\'t switch to HTML mode\n        in this state. Remove all failed uploads and continue?</string>
	<string name="format_bar_description_html">HTML mode</string>
	<string name="visual_editor">Visual editor</string>
	<string name="image_thumbnail">Image thumbnail</string>
	<string name="format_bar_description_ul">Unordered list</string>
	<string name="format_bar_description_ol">Ordered list</string>
	<string name="format_bar_description_more">Insert more</string>
	<string name="format_bar_description_media">Insert media</string>
	<string name="format_bar_description_strike">Strikethrough</string>
	<string name="format_bar_description_quote">Block quote</string>
	<string name="format_bar_description_link">Insert link</string>
	<string name="format_bar_description_italic">Italic</string>
	<string name="format_bar_description_underline">Underline</string>
	<string name="image_settings_save_toast">Changes saved</string>
	<string name="image_caption">Caption</string>
	<string name="image_alt_text">Alt text</string>
	<string name="image_link_to">Link to</string>
	<string name="image_width">Width</string>
	<string name="format_bar_description_bold">Bold</string>
	<string name="image_settings_dismiss_dialog_title">Discard unsaved changes?</string>
	<string name="stop_upload_dialog_title">Stop uploading?</string>
	<string name="stop_upload_button">Stop Upload</string>
	<string name="alert_error_adding_media">An error occurred while inserting media</string>
	<string name="alert_action_while_uploading">You are currently uploading media. Please wait until this completes.</string>
	<string name="alert_insert_image_html_mode">Can\'t insert media directly in HTML mode. Please switch back to visual mode.</string>
	<string name="uploading_gallery_placeholder">Uploading gallery…</string>
	<string name="invite_error_some_failed">Invite sent but error(s) occurred!</string>
	<string name="invite_error_for_username">%1$s: %2$s</string>
	<string name="invite_sent">Invite sent successfully</string>
	<string name="tap_to_try_again">Tap to try again!</string>
	<string name="invite_error_sending">An error occurred while trying to send the invite!</string>
	<string name="invite_error_invalid_usernames_multiple">Cannot send: There are invalid usernames or emails</string>
	<string name="invite_error_invalid_usernames_one">Cannot send: A username or email is invalid</string>
	<string name="invite_error_no_usernames">Please add at least one username</string>
	<string name="invite_message_info">(Optional) You can enter a custom message of up to 500 characters that will be included in the invitation to the user(s).</string>
	<string name="invite_message_remaining_other">%d characters remaining</string>
	<string name="invite_message_remaining_one">1 character remaining</string>
	<string name="invite_message_remaining_zero">0 characters remaining</string>
	<string name="invite_invalid_email">The email address \'%s\' is invalid</string>
	<string name="invite_message_title">Custom Message</string>
	<string name="invite_already_a_member">There\'s already a member with username \'%s\'</string>
	<string name="invite_username_not_found">No user was found for username \'%s\'</string>
	<string name="invite">Invite</string>
	<string name="invite_names_title">Usernames or Emails</string>
	<string name="signup_succeed_signin_failed">Your account has been created but an error occurred while we signed you\n        in. Try to sign in with your newly created username and password.</string>
	<string name="send_link">Send link</string>
	<string name="my_site_header_external">External</string>
	<string name="invite_people">Invite People</string>
	<string name="label_clear_search_history">Clear search history</string>
	<string name="dlg_confirm_clear_search_history">Clear search history?</string>
	<string name="reader_empty_posts_in_search_description">No posts found for %s for your language</string>
	<string name="reader_label_post_search_running">Searching…</string>
	<string name="reader_label_related_posts">Related Reading</string>
	<string name="reader_empty_posts_in_search_title">No posts found</string>
	<string name="reader_label_post_search_explainer">Search all public WordPress.com blogs</string>
	<string name="reader_hint_post_search">Search WordPress.com</string>
	<string name="reader_title_related_post_detail">Related Post</string>
	<string name="reader_title_search_results">Search for %s</string>
	<string name="preview_screen_links_disabled">Links are disabled on the preview screen</string>
	<string name="draft_explainer">This post is a draft which hasn\'t been published</string>
	<string name="send">Send</string>
	<string name="user_remove_confirmation_message">If you remove %1$s, that user will no longer be able to access this site, but any content that was created by %1$s will remain on the site.\n\nWould you still like to remove this user?</string>
	<string name="person_removed">Successfully removed %1$s</string>
	<string name="person_remove_confirmation_title">Remove %1$s</string>
	<string name="reader_empty_posts_in_custom_list">The sites in this list haven\'t posted anything recently</string>
	<string name="people">People</string>
	<string name="edit_user">Edit User</string>
	<string name="role">Role</string>
	<string name="error_remove_user">Couldn\'t remove user</string>
	<string name="error_fetch_viewers_list">Couldn\'t retrieve site viewers</string>
	<string name="error_update_role">Couldn\'t update user role</string>
	<string name="gravatar_camera_and_media_permission_required">Permissions required in order to select or capture a photo</string>
	<string name="error_updating_gravatar">Error updating your Gravatar</string>
	<string name="error_locating_image">Error locating the cropped image</string>
	<string name="error_refreshing_gravatar">Error reloading your Gravatar</string>
	<string name="gravatar_tip">New! Tap your Gravatar to change it!</string>
	<string name="error_cropping_image">Error cropping the image</string>
	<string name="launch_your_email_app">Launch your email app</string>
	<string name="checking_email">Checking email</string>
	<string name="not_on_wordpress_com">Not on WordPress.com?</string>
	<string name="magic_link_unavailable_error_message">Currently unavailable. Please enter your password</string>
	<string name="check_your_email">Check your email</string>
	<string name="get_a_link_sent_to_your_email_to_sign_in_instantly">Get a link sent to your email to sign in instantly</string>
	<string name="logging_in">Logging in</string>
	<string name="enter_your_password_instead">Enter your password instead</string>
	<string name="web_address_dialog_hint">Shown publicly when you comment.</string>
	<string name="jetpack_not_connected_message">The Jetpack plugin is installed, but not connected to WordPress.com. Do you want to connect Jetpack?</string>
	<string name="username_email">Email or username</string>
	<string name="jetpack_not_connected">Jetpack plugin not connected</string>
	<string name="new_editor_reflection_error">Visual editor is not compatible with your device. It was\n        automatically disabled.</string>
	<string name="stats_insights_latest_post_no_title">(no title)</string>
	<string name="capture_or_pick_photo">Capture or select photo</string>
	<string name="plans_post_purchase_text_themes">You now have unlimited access to Premium themes. Preview any theme on your site to get started.</string>
	<string name="plans_post_purchase_button_themes">Browse Themes</string>
	<string name="plans_post_purchase_title_themes">Find a perfect, Premium theme</string>
	<string name="plans_post_purchase_button_video">Start new post</string>
	<string name="plans_post_purchase_text_video">You can upload and host videos on your site with VideoPress and your expanded media storage.</string>
	<string name="plans_post_purchase_title_video">Bring posts to life with video</string>
	<string name="plans_post_purchase_button_customize">Customise my Site</string>
	<string name="plans_post_purchase_text_customize">You now have access to custom fonts, custom colours, and custom CSS editing capabilities.</string>
	<string name="plans_post_purchase_text_intro">Your site is doing somersaults in excitement! Now explore your site\'s new features and choose where you\'d like to begin.</string>
	<string name="plans_post_purchase_title_customize">Customise Fonts &amp; Colours</string>
	<string name="plans_post_purchase_title_intro">It\'s all yours, way to go!</string>
	<string name="export_your_content_message">Your posts, pages, and settings will be emailed to you at %s.</string>
	<string name="plan">Plan</string>
	<string name="plans">Plans</string>
	<string name="plans_loading_error">Unable to load plans</string>
	<string name="export_your_content">Export your content</string>
	<string name="exporting_content_progress">Exporting content…</string>
	<string name="export_email_sent">Export email sent!</string>
	<string name="premium_upgrades_message">You have active premium upgrades on your site. Please cancel your upgrades prior to deleting your site.</string>
	<string name="show_purchases">Show purchases</string>
	<string name="checking_purchases">Checking purchases</string>
	<string name="premium_upgrades_title">Premium Upgrades</string>
	<string name="purchases_request_error">Something went wrong. Could not request purchases.</string>
	<string name="delete_site_progress">Deleting site…</string>
	<string name="delete_site_summary">This action cannot be undone. Deleting your site will remove all content, contributors, and domains from the site.</string>
	<string name="delete_site_hint">Delete site</string>
	<string name="export_site_hint">Export your site to an XML file</string>
	<string name="are_you_sure">Are You Sure?</string>
	<string name="export_site_summary">If you are sure, please be sure to take the time and export your content now. It cannot be recovered in the future.</string>
	<string name="keep_your_content">Keep Your Content</string>
	<string name="domain_removal_hint">The domains that will not work once you remove your site</string>
	<string name="domain_removal_summary">Be careful! Deleting your site will also remove your domain(s) listed below.</string>
	<string name="primary_domain">Primary Domain</string>
	<string name="domain_removal">Domain Removal</string>
	<string name="error_deleting_site_summary">There was an error in deleting your site. Please contact support for more assistance</string>
	<string name="error_deleting_site">Error deleting site</string>
	<string name="confirm_delete_site_prompt">Please type %1$s in the field below to confirm. Your site will then be gone forever.</string>
	<string name="site_settings_export_content_title">Export content</string>
	<string name="contact_support">Contact support</string>
	<string name="confirm_delete_site">Confirm Delete Site</string>
	<string name="start_over_text">If you want a site but don\'t want any of the posts and pages you have now, our support team can delete your posts, pages, media and comments for you.\n\nThis will keep your site and URL active, but give you a fresh start on your content creation. Just contact us to have your current content cleared out.</string>
	<string name="site_settings_start_over_hint">Start your site again</string>
	<string name="let_us_help">Let Us Help</string>
	<string name="me_btn_app_settings">App Settings</string>
	<string name="start_over">Start Over</string>
	<string name="editor_remove_failed_uploads">Remove failed uploads</string>
	<string name="editor_toast_failed_uploads">Some media uploads have failed. You can\'t save or publish\n        your post in this state. Would you like to remove all failed media?</string>
	<string name="comments_empty_list_filtered_trashed">No Binned comments</string>
	<string name="site_settings_advanced_header">Advanced</string>
	<string name="comments_empty_list_filtered_pending">No Pending comments</string>
	<string name="comments_empty_list_filtered_approved">No Approved comments</string>
	<string name="button_done">Done</string>
	<string name="button_skip">Skip</string>
	<string name="site_timeout_error">Couldn\'t connect to the WordPress site due to Timeout error.</string>
	<string name="xmlrpc_malformed_response_error">Couldn\'t connect. The WordPress installation responded with an invalid XML-RPC document.</string>
	<string name="xmlrpc_missing_method_error">Couldn\'t connect. Required XML-RPC methods are missing on the server.</string>
	<string name="post_format_status">Status</string>
	<string name="post_format_video">Video</string>
	<string name="alignment_center">Centre</string>
	<string name="theme_free">Free</string>
	<string name="theme_all">All</string>
	<string name="theme_premium">Premium</string>
	<string name="post_format_chat">Chat</string>
	<string name="post_format_gallery">Gallery</string>
	<string name="post_format_image">Image</string>
	<string name="post_format_link">Link</string>
	<string name="post_format_quote">Quote</string>
	<string name="post_format_standard">Standard</string>
	<string name="notif_events">Information on WordPress.com courses and events (online &amp; in-person).</string>
	<string name="post_format_aside">Aside</string>
	<string name="post_format_audio">Audio</string>
	<string name="notif_surveys">Opportunities to participate in WordPress.com research &amp; surveys.</string>
	<string name="notif_tips">Tips for getting the most out of WordPress.com.</string>
	<string name="notif_community">Community</string>
	<string name="replies_to_my_comments">Replies to my comments</string>
	<string name="notif_suggestions">Suggestions</string>
	<string name="notif_research">Research</string>
	<string name="site_achievements">Site achievements</string>
	<string name="username_mentions">Username mentions</string>
	<string name="likes_on_my_posts">Likes on my posts</string>
	<string name="site_follows">Site follows</string>
	<string name="likes_on_my_comments">Likes on my comments</string>
	<string name="comments_on_my_site">Comments on my site</string>
	<string name="site_settings_list_editor_summary_other">%d items</string>
	<string name="site_settings_list_editor_summary_one">1 item</string>
	<string name="approve_auto_if_previously_approved">Known users\' comments</string>
	<string name="approve_auto">All users</string>
	<string name="approve_manual">No comments</string>
	<string name="site_settings_paging_summary_other">%d comments per page</string>
	<string name="site_settings_paging_summary_one">1 comment per page</string>
	<string name="site_settings_multiple_links_summary_other">Require approval for more than %d links</string>
	<string name="site_settings_multiple_links_summary_one">Require approval for more than 1 link</string>
	<string name="site_settings_multiple_links_summary_zero">Require approval for more than 0 links</string>
	<string name="detail_approve_auto">Automatically approve everyone\'s comments.</string>
	<string name="detail_approve_auto_if_previously_approved">Automatically approve if the user has a previously approved comment</string>
	<string name="detail_approve_manual">Require manual approval for everyone\'s comments.</string>
	<string name="filter_trashed_posts">Binned</string>
	<string name="days_quantity_one">1 day</string>
	<string name="days_quantity_other">%d days</string>
	<string name="filter_published_posts">Published</string>
	<string name="filter_draft_posts">Drafts</string>
	<string name="filter_scheduled_posts">Scheduled</string>
	<string name="pending_email_change_snackbar">Click the verification link in the email sent to %1$s to confirm your new address</string>
	<string name="primary_site">Primary site</string>
	<string name="web_address">Web Address</string>
	<string name="editor_toast_uploading_please_wait">You are currently uploading media. Please wait until this completes.</string>
	<string name="error_refresh_comments_showing_older">Comments couldn\'t be refreshed at this time - showing older comments</string>
	<string name="editor_post_settings_set_featured_image">Set Featured Image</string>
	<string name="editor_post_settings_featured_image">Featured Image</string>
	<string name="new_editor_promo_desc">The WordPress app for Android now includes a beautiful new visual\n    editor. Try it out by creating a new post.</string>
	<string name="new_editor_promo_title">Brand new editor</string>
	<string name="new_editor_promo_button_label">Great, thanks!</string>
	<string name="visual_editor_enabled">Visual Editor enabled</string>
	<string name="editor_content_placeholder">Share your story here…</string>
	<string name="editor_page_title_placeholder">Page Title</string>
	<string name="editor_post_title_placeholder">Post Title</string>
	<string name="email_address">Email address</string>
	<string name="preference_show_visual_editor">Show visual editor</string>
	<string name="dlg_sure_to_delete_comments">Permanently delete these comments?</string>
	<string name="preference_editor">Editor</string>
	<string name="dlg_sure_to_delete_comment">Permanently delete this comment?</string>
	<string name="mnu_comment_delete_permanently">Delete</string>
	<string name="comment_deleted_permanently">Comment deleted</string>
	<string name="mnu_comment_untrash">Restore</string>
	<string name="comments_empty_list_filtered_spam">No Spam comments</string>
	<string name="could_not_load_page">Could not load page</string>
	<string name="comment_status_all">All</string>
	<string name="interface_language">Interface Language</string>
	<string name="off">Off</string>
	<string name="about_the_app">About the app</string>
	<string name="error_post_account_settings">Couldn\'t save your account settings</string>
	<string name="error_post_my_profile">Couldn\'t save your profile</string>
	<string name="error_fetch_account_settings">Couldn\'t retrieve your account settings</string>
	<string name="error_fetch_my_profile">Couldn\'t retrieve your profile</string>
	<string name="stats_widget_promo_ok_btn_label">OK, got it</string>
	<string name="stats_widget_promo_desc">Add the widget to your home screen to access your Stats in one click.</string>
	<string name="stats_widget_promo_title">Home Screen Stats Widget</string>
	<string name="site_settings_unknown_language_code_error">Language code not recognised</string>
	<string name="site_settings_threading_dialog_description">Allow comments to be nested in threads.</string>
	<string name="site_settings_threading_dialog_header">Thread up to</string>
	<string name="remove">Remove</string>
	<string name="search">Search</string>
	<string name="add_category">Add category</string>
	<string name="disabled">Disabled</string>
	<string name="site_settings_image_original_size">Original Size</string>
	<string name="privacy_private">Your site is visible only to you and users you approve</string>
	<string name="privacy_public_not_indexed">Your site is visible to everyone but asks search engines not to index it</string>
	<string name="privacy_public">Your site is visible to everyone and may be indexed by search engines</string>
	<string name="about_me_hint">A few words about you…</string>
	<string name="public_display_name_hint">Display name will default to your username if it is not set</string>
	<string name="about_me">About me</string>
	<string name="public_display_name">Public display name</string>
	<string name="my_profile">My Profile</string>
	<string name="first_name">First name</string>
	<string name="last_name">Last name</string>
	<string name="site_privacy_public_desc">Allow search engines to index this site</string>
	<string name="site_privacy_hidden_desc">Discourage search engines from indexing this site</string>
	<string name="site_privacy_private_desc">I would like my site to be private, visible only to users I choose</string>
	<string name="cd_related_post_preview_image">Related post preview image</string>
	<string name="error_post_remote_site_settings">Couldn\'t save site info</string>
	<string name="error_fetch_remote_site_settings">Couldn\'t retrieve site info</string>
	<string name="error_media_upload_connection">A connection error occurred while uploading media</string>
	<string name="site_settings_disconnected_toast">Disconnected, editing disabled.</string>
	<string name="site_settings_unsupported_version_error">Unsupported WordPress version</string>
	<string name="site_settings_multiple_links_dialog_description">Require approval for comments that include more than this number of links.</string>
	<string name="site_settings_close_after_dialog_switch_text">Automatically close</string>
	<string name="site_settings_close_after_dialog_description">Automatically close comments on articles.</string>
	<string name="site_settings_paging_dialog_description">Break comment threads into multiple pages.</string>
	<string name="site_settings_paging_dialog_header">Comments per page</string>
	<string name="site_settings_close_after_dialog_title">Close commenting</string>
	<string name="site_settings_blacklist_description">When a comment contains any of these words in its content, name, URL, email, or IP, it will be marked as spam. You can enter partial words, so "press" will match "WordPress."</string>
	<string name="site_settings_hold_for_moderation_description">When a comment contains any of these words in its content, name, URL, email, or IP, it will be held in the moderation queue. You can enter partial words, so "press" will match "WordPress."</string>
	<string name="site_settings_list_editor_input_hint">Enter a word or phrase</string>
	<string name="site_settings_list_editor_no_items_text">No items</string>
	<string name="site_settings_learn_more_caption">You can override these settings for individual posts.</string>
	<string name="site_settings_rp_preview3_site">in "Upgrade"</string>
	<string name="site_settings_rp_preview3_title">Upgrade Focus: VideoPress For Weddings</string>
	<string name="site_settings_rp_preview2_site">in "Apps"</string>
	<string name="site_settings_rp_preview2_title">The WordPress for Android App Gets a Big Facelift</string>
	<string name="site_settings_rp_preview1_site">in "Mobile"</string>
	<string name="site_settings_rp_preview1_title">Big iPhone/iPad Update Now Available</string>
	<string name="site_settings_rp_show_images_title">Show Images</string>
	<string name="site_settings_rp_show_header_title">Show Header</string>
	<string name="site_settings_rp_switch_summary">Related Posts displays relevant content from your site below your posts.</string>
	<string name="site_settings_rp_switch_title">Show Related Posts</string>
	<string name="site_settings_delete_site_hint">Removes your site data from the app</string>
	<string name="site_settings_blacklist_hint">Comments that match a filter are marked as spam</string>
	<string name="site_settings_moderation_hold_hint">Comments that match a filter are put in the moderation queue</string>
	<string name="site_settings_multiple_links_hint">Ignores link limit from known users</string>
	<string name="site_settings_whitelist_hint">Comment author must have a previously approved comment</string>
	<string name="site_settings_user_account_required_hint">Users must be registered and logged in to comment</string>
	<string name="site_settings_identity_required_hint">Comment author must fill out name and e-mail</string>
	<string name="site_settings_manual_approval_hint">Comments must be manually approved</string>
	<string name="site_settings_paging_hint">Display comments in chunks of a specified size</string>
	<string name="site_settings_threading_hint">Allow nested comments to a certain depth</string>
	<string name="site_settings_sort_by_hint">Determines the order comments are displayed</string>
	<string name="site_settings_close_after_hint">Disallow comments after the specified time</string>
	<string name="site_settings_receive_pingbacks_hint">Allow link notifications from other blogs</string>
	<string name="site_settings_send_pingbacks_hint">Attempt to notify any blogs linked to from the article</string>
	<string name="site_settings_allow_comments_hint">Allow readers to post comments</string>
	<string name="site_settings_discussion_hint">View and change your sites discussion settings</string>
	<string name="site_settings_more_hint">View all available Discussion settings</string>
	<string name="site_settings_related_posts_hint">Show or hide related posts in reader</string>
	<string name="site_settings_upload_and_link_image_hint">Enable to always upload the fullsize image</string>
	<string name="site_settings_image_width_hint">Resizes images in posts to this width</string>
	<string name="site_settings_format_hint">Sets new post format</string>
	<string name="site_settings_category_hint">Sets new post category</string>
	<string name="site_settings_location_hint">Automatically add location data to your posts</string>
	<string name="site_settings_password_hint">Change your password</string>
	<string name="site_settings_username_hint">Current user account</string>
	<string name="site_settings_language_hint">Language this blog is primarily written in</string>
	<string name="site_settings_privacy_hint">Controls who can see your site</string>
	<string name="site_settings_address_hint">Changing your address is not currently supported</string>
	<string name="site_settings_tagline_hint">A short description or catchy phrase to describe your blog</string>
	<string name="site_settings_title_hint">In a few words, explain what this site is about</string>
	<string name="site_settings_whitelist_known_summary">Comments from known users</string>
	<string name="site_settings_whitelist_all_summary">Comments from all users</string>
	<string name="site_settings_threading_summary">%d levels</string>
	<string name="site_settings_privacy_private_summary">Private</string>
	<string name="site_settings_privacy_hidden_summary">Hidden</string>
	<string name="site_settings_delete_site_title">Delete Site</string>
	<string name="site_settings_privacy_public_summary">Public</string>
	<string name="site_settings_blacklist_title">Blacklist</string>
	<string name="site_settings_moderation_hold_title">Hold for Moderation</string>
	<string name="site_settings_multiple_links_title">Links in comments</string>
	<string name="site_settings_whitelist_title">Automatically approve</string>
	<string name="site_settings_threading_title">Threading</string>
	<string name="site_settings_paging_title">Paging</string>
	<string name="site_settings_sort_by_title">Sort by</string>
	<string name="site_settings_account_required_title">Users must be signed in</string>
	<string name="site_settings_identity_required_title">Must include name and email</string>
	<string name="site_settings_receive_pingbacks_title">Receive Pingbacks</string>
	<string name="site_settings_send_pingbacks_title">Send Pingbacks</string>
	<string name="site_settings_allow_comments_title">Allow Comments</string>
	<string name="site_settings_default_format_title">Default Format</string>
	<string name="site_settings_default_category_title">Default Category</string>
	<string name="site_settings_location_title">Enable Location</string>
	<string name="site_settings_address_title">Address</string>
	<string name="site_settings_title_title">Site Title</string>
	<string name="site_settings_tagline_title">Tagline</string>
	<string name="site_settings_this_device_header">This device</string>
	<string name="site_settings_discussion_new_posts_header">Defaults for new posts</string>
	<string name="site_settings_account_header">Account</string>
	<string name="site_settings_writing_header">Writing</string>
	<string name="newest_first">Newest first</string>
	<string name="site_settings_general_header">General</string>
	<string name="discussion">Discussion</string>
	<string name="privacy">Privacy</string>
	<string name="related_posts">Related Posts</string>
	<string name="comments">Comments</string>
	<string name="close_after">Close after</string>
	<string name="oldest_first">Oldest first</string>
	<string name="media_error_no_permission_upload">You don\'t have permission to upload media to the site</string>
	<string name="never">Never</string>
	<string name="unknown">Unknown</string>
	<string name="reader_err_get_post_not_found">This post no longer exists</string>
	<string name="reader_err_get_post_not_authorized">You\'re not authorised to view this post</string>
	<string name="reader_err_get_post_generic">Unable to retrieve this post</string>
	<string name="blog_name_no_spaced_allowed">Site address can\'t contain spaces</string>
	<string name="invalid_username_no_spaces">Username can\'t contain spaces</string>
	<string name="reader_empty_followed_blogs_no_recent_posts_description">The sites you follow haven\'t posted anything recently</string>
	<string name="reader_empty_followed_blogs_no_recent_posts_title">No recent posts</string>
	<string name="media_details_copy_url_toast">URL copied to clipboard</string>
	<string name="edit_media">Edit media</string>
	<string name="media_details_copy_url">Copy URL</string>
	<string name="media_details_label_date_uploaded">Uploaded</string>
	<string name="media_details_label_date_added">Added</string>
	<string name="selected_theme">Selected Theme</string>
	<string name="could_not_load_theme">Could not load theme</string>
	<string name="theme_activation_error">Something went wrong. Could not activate theme</string>
	<string name="theme_by_author_prompt_append"> by %1$s</string>
	<string name="theme_prompt">Thanks for choosing %1$s</string>
	<string name="theme_try_and_customize">Try &amp; Customise</string>
	<string name="theme_view">View</string>
	<string name="theme_details">Details</string>
	<string name="theme_support">Support</string>
	<string name="theme_done">DONE</string>
	<string name="theme_manage_site">MANAGE SITE</string>
	<string name="title_activity_theme_support">Themes</string>
	<string name="theme_activate">Activate</string>
	<string name="date_range_start_date">Start Date</string>
	<string name="date_range_end_date">End Date</string>
	<string name="current_theme">Current Theme</string>
	<string name="customize">Customise</string>
	<string name="details">Details</string>
	<string name="support">Support</string>
	<string name="active">Active</string>
	<string name="stats_referrers_spam_generic_error">Something went wrong during the operation. The spam state wasn\'t changed.</string>
	<string name="stats_referrers_marking_not_spam">Marking as not spam</string>
	<string name="stats_referrers_unspam">Not spam</string>
	<string name="stats_referrers_marking_spam">Marking as spam</string>
	<string name="theme_auth_error_authenticate">Failed to fetch themes: failed authenticating user</string>
	<string name="post_published">Post published</string>
	<string name="page_published">Page published</string>
	<string name="post_updated">Post updated</string>
	<string name="page_updated">Page updated</string>
	<string name="stats_referrers_spam">Spam</string>
	<string name="theme_no_search_result_found">Sorry, no themes found.</string>
	<string name="media_file_name">File name: %s</string>
	<string name="media_uploaded_on">Uploaded on: %s</string>
	<string name="media_dimensions">Dimensions: %s</string>
	<string name="upload_queued">Queued</string>
	<string name="media_file_type">File type: %s</string>
	<string name="reader_label_gap_marker">Load more posts</string>
	<string name="notifications_no_search_results">No sites matched \'%s\'</string>
	<string name="search_sites">Search sites</string>
	<string name="notifications_empty_view_reader">View Reader</string>
	<string name="unread">Unread</string>
	<string name="notifications_empty_action_followers_likes">Get noticed: comment on posts you\'ve read.</string>
	<string name="notifications_empty_action_comments">Join a conversation: comment on posts from blogs you follow.</string>
	<string name="notifications_empty_action_unread">Reignite the conversation: write a new post.</string>
	<string name="notifications_empty_action_all">Get active! Comment on posts from blogs you follow.</string>
	<string name="notifications_empty_likes">No new likes to show…yet.</string>
	<string name="notifications_empty_followers">No new followers to report…yet.</string>
	<string name="notifications_empty_comments">No new comments…yet.</string>
	<string name="notifications_empty_unread">You\'re all caught up!</string>
	<string name="stats_widget_error_jetpack_no_blogid">Please access the Stats in the app, and try adding the widget later</string>
	<string name="stats_widget_error_readd_widget">Please remove the widget and re-add it again</string>
	<string name="stats_widget_error_no_visible_blog">Stats couldn\'t be accessed without a visible blog</string>
	<string name="stats_widget_error_no_permissions">Your WordPress.com account can\'t access Stats on this blog</string>
	<string name="stats_widget_error_no_account">Please login into WordPress</string>
	<string name="stats_widget_error_generic">Stats couldn\'t be loaded</string>
	<string name="stats_widget_loading_data">Loading data…</string>
	<string name="stats_widget_name_for_blog">Today\'s Stats for %1$s</string>
	<string name="stats_widget_name">WordPress Today\'s Stats</string>
	<string name="add_location_permission_required">Permission required in order to add location</string>
	<string name="add_media_permission_required">Permissions required in order to add media</string>
	<string name="access_media_permission_required">Permissions required in order to access media</string>
	<string name="stats_enable_rest_api_in_jetpack">To view your stats, enable the JSON API module in Jetpack.</string>
	<string name="error_open_list_from_notification">This post or page was published on another site</string>
	<string name="reader_short_comment_count_multi">%s Comments</string>
	<string name="reader_short_comment_count_one">1 Comment</string>
	<string name="reader_label_submit_comment">SEND</string>
	<string name="reader_hint_comment_on_post">Reply to post…</string>
	<string name="reader_discover_visit_blog">Visit %s</string>
	<string name="reader_discover_attribution_blog">Originally posted on %s</string>
	<string name="reader_discover_attribution_author">Originally posted by %s</string>
	<string name="reader_discover_attribution_author_and_blog">Originally posted by %1$s on %2$s</string>
	<string name="reader_short_like_count_multi">%s Likes</string>
	<string name="reader_short_like_count_one">1 Like</string>
	<string name="reader_label_follow_count">%,d followers</string>
	<string name="reader_short_like_count_none">Like</string>
	<string name="reader_menu_tags">Edit tags and blogs</string>
	<string name="reader_title_post_detail">Reader Post</string>
	<string name="local_draft_explainer">This post is a local draft which hasn\'t been published</string>
	<string name="local_changes_explainer">This post has local changes which haven\'t been published</string>
	<string name="notifications_push_summary">Settings for notifications that appear on your device.</string>
	<string name="notifications_email_summary">Settings for notifications that are sent to the email tied to your account.</string>
	<string name="notifications_tab_summary">Settings for notifications that appear in the Notifications tab.</string>
	<string name="notifications_disabled">App notifications have been disabled. Tap here to enable them in Settings.</string>
	<string name="notification_types">Notification Types</string>
	<string name="error_loading_notifications">Couldn\'t load notification settings</string>
	<string name="replies_to_your_comments">Replies to your comments</string>
	<string name="comment_likes">Comment likes</string>
	<string name="app_notifications">App notifications</string>
	<string name="notifications_tab">Notifications tab</string>
	<string name="email">Email</string>
	<string name="notifications_comments_other_blogs">Comments on other sites</string>
	<string name="notifications_wpcom_updates">WordPress.com Updates</string>
	<string name="notifications_other">Other</string>
	<string name="notifications_account_emails">Email from WordPress.com</string>
	<string name="notifications_account_emails_summary">We\'ll always send important emails regarding your account, but you can get some helpful extras, too.</string>
	<string name="notifications_sights_and_sounds">Sights and Sounds</string>
	<string name="your_sites">Your Sites</string>
	<string name="stats_insights_latest_post_trend">It\'s been %1$s since %2$s was published. Here\'s how the post has performed so far…</string>
	<string name="stats_insights_latest_post_summary">Latest Post Summary</string>
	<string name="button_revert">Revert</string>
	<string name="days_ago">%d days ago</string>
	<string name="yesterday">Yesterday</string>
	<string name="connectionbar_no_connection">No connection</string>
	<string name="page_trashed">Page sent to bin</string>
	<string name="post_deleted">Post deleted</string>
	<string name="post_trashed">Post sent to bin</string>
	<string name="stats_no_activity_this_period">No activity this period</string>
	<string name="trashed">Binned</string>
	<string name="button_back">Back</string>
	<string name="page_deleted">Page deleted</string>
	<string name="button_stats">Stats</string>
	<string name="button_trash">Bin</string>
	<string name="button_preview">Preview</string>
	<string name="button_view">View</string>
	<string name="button_edit">Edit</string>
	<string name="button_publish">Publish</string>
	<string name="my_site_no_sites_view_subtitle">Would you like to add one?</string>
	<string name="my_site_no_sites_view_title">You don\'t have any WordPress sites yet.</string>
	<string name="my_site_no_sites_view_drake">Illustration</string>
	<string name="reader_toast_err_follow_blog_not_authorized">You are not authorised to access this blog</string>
	<string name="reader_toast_err_follow_blog_not_found">This blog could not be found</string>
	<string name="undo">Undo</string>
	<string name="tabbar_accessibility_label_my_site">My Site</string>
	<string name="tabbar_accessibility_label_me">Me</string>
	<string name="passcodelock_prompt_message">Enter your PIN</string>
	<string name="editor_toast_changes_saved">Changes saved</string>
	<string name="push_auth_expired">The request has expired. Sign in to WordPress.com to try again.</string>
	<string name="stats_insights_best_ever">Best Views Ever</string>
	<string name="ignore">Ignore</string>
	<string name="stats_insights_most_popular_percent_views">%1$d%% of views</string>
	<string name="stats_insights_most_popular_hour">Most popular hour</string>
	<string name="stats_insights_most_popular_day">Most popular day</string>
	<string name="stats_insights_popular">Most popular day and hour</string>
	<string name="stats_insights_today">Today\'s Stats</string>
	<string name="stats_insights_all_time">All-time posts, views, and visitors</string>
	<string name="stats_insights">Insights</string>
	<string name="stats_sign_in_jetpack_different_com_account">To view your stats, sign in to the WordPress.com account you used to connect Jetpack.</string>
	<string name="stats_other_recent_stats_moved_label">Looking for your Other Recent Stats? We\'ve moved them to the Insights page.</string>
	<string name="me_disconnect_from_wordpress_com">Disconnect from WordPress.com</string>
	<string name="me_connect_to_wordpress_com">Connect to WordPress.com</string>
	<string name="me_btn_login_logout">Login/Logout</string>
	<string name="account_settings">Account Settings</string>
	<string name="me_btn_support">Help &amp; Support</string>
	<string name="site_picker_cant_hide_current_site">"%s" wasn\'t hidden because it\'s the current site</string>
	<string name="site_picker_create_dotcom">Create WordPress.com site</string>
	<string name="site_picker_add_site">Add site</string>
	<string name="site_picker_add_self_hosted">Add self-hosted site</string>
	<string name="site_picker_edit_visibility">Show/hide sites</string>
	<string name="my_site_btn_view_admin">View Admin</string>
	<string name="my_site_btn_view_site">View Site</string>
	<string name="site_picker_title">Choose site</string>
	<string name="my_site_btn_switch_site">Switch Site</string>
	<string name="my_site_btn_blog_posts">Blog Posts</string>
	<string name="my_site_btn_site_settings">Settings</string>
	<string name="my_site_header_look_and_feel">Look and Feel</string>
	<string name="my_site_header_publish">Publish</string>
	<string name="my_site_header_configuration">Configuration</string>
	<string name="reader_label_new_posts_subtitle">Tap to show them</string>
	<string name="notifications_account_required">Sign in to WordPress.com for notifications</string>
	<string name="stats_unknown_author">Unknown Author</string>
	<string name="image_added">Image added</string>
	<string name="signout">Disconnect</string>
	<string name="deselect_all">Deselect all</string>
	<string name="show">Show</string>
	<string name="hide">Hide</string>
	<string name="select_all">Select all</string>
	<string name="sign_out_wpcom_confirm">Disconnecting your account will remove all of @%s’s WordPress.com data from this device, including local drafts and local changes.</string>
	<string name="select_from_new_picker">Multi-select with the new picker</string>
	<string name="stats_generic_error">Required Stats couldn\'t be loaded</string>
	<string name="no_device_videos">No videos</string>
	<string name="no_blog_images">No images</string>
	<string name="no_blog_videos">No videos</string>
	<string name="no_device_images">No images</string>
	<string name="error_loading_blog_images">Unable to fetch images</string>
	<string name="error_loading_blog_videos">Unable to fetch videos</string>
	<string name="error_loading_images">Error loading images</string>
	<string name="error_loading_videos">Error loading videos</string>
	<string name="loading_blog_images">Fetching images</string>
	<string name="loading_blog_videos">Fetching videos</string>
	<string name="no_media_sources">Couldn\'t fetch media</string>
	<string name="loading_videos">Loading videos</string>
	<string name="loading_images">Loading images</string>
	<string name="no_media">No media</string>
	<string name="device">Device</string>
	<string name="language">Language</string>
	<string name="add_to_post">Add to Post</string>
	<string name="media_picker_title">Select media</string>
	<string name="take_photo">Take a photo</string>
	<string name="take_video">Take a video</string>
	<string name="tab_title_device_images">Device Images</string>
	<string name="tab_title_device_videos">Device Videos</string>
	<string name="tab_title_site_images">Site Images</string>
	<string name="tab_title_site_videos">Site Videos</string>
	<string name="media_details_label_file_name">File name</string>
	<string name="media_details_label_file_type">File type</string>
	<string name="error_publish_no_network">Can\'t publish while there is no connection. Saved as draft.</string>
	<string name="editor_toast_invalid_path">Invalid file path</string>
	<string name="verification_code">Verification code</string>
	<string name="invalid_verification_code">Invalid verification code</string>
	<string name="verify">Verify</string>
	<string name="two_step_footer_label">Enter the code from your authenticator app.</string>
	<string name="two_step_footer_button">Send code via text message</string>
	<string name="two_step_sms_sent">Check your text messages for the verification code.</string>
	<string name="sign_in_jetpack">Sign in to your WordPress.com account to connect to Jetpack.</string>
	<string name="auth_required">Sign in again to continue.</string>
	<string name="reader_empty_posts_request_failed">Unable to retrieve posts</string>
	<string name="publisher">Publisher:</string>
	<string name="error_notification_open">Could not open notification</string>
	<string name="stats_followers_total_email_paged">Showing %1$d - %2$d of %3$s Email Followers</string>
	<string name="stats_search_terms_unknown_search_terms">Unknown Search Terms</string>
	<string name="stats_followers_total_wpcom_paged">Showing %1$d - %2$d of %3$s WordPress.com Followers</string>
	<string name="stats_empty_search_terms_desc">Learn more about your search traffic by looking at the terms your visitors searched for to find your site.</string>
	<string name="stats_empty_search_terms">No search terms recorded</string>
	<string name="stats_entry_search_terms">Search Term</string>
	<string name="stats_view_authors">Authors</string>
	<string name="stats_view_search_terms">Search Terms</string>
	<string name="comments_fetching">Fetching comments…</string>
	<string name="pages_fetching">Fetching pages…</string>
	<string name="toast_err_post_uploading">Unable to open post while it\'s uploading</string>
	<string name="posts_fetching">Fetching posts…</string>
	<string name="media_fetching">Fetching media…</string>
	<string name="post_uploading">Uploading</string>
	<string name="stats_total">Total</string>
	<string name="stats_overall">Overall</string>
	<string name="stats_period">Period</string>
	<string name="logs_copied_to_clipboard">Application logs have been copied to the clipboard</string>
	<string name="reader_label_new_posts">New posts</string>
	<string name="reader_empty_posts_in_blog">This blog is empty</string>
	<string name="stats_average_per_day">Average per Day</string>
	<string name="stats_recent_weeks">Recent Weeks</string>
	<string name="error_copy_to_clipboard">An error occurred while copying text to clipboard</string>
	<string name="reader_page_recommended_blogs">Sites you may like</string>
	<string name="stats_months_and_years">Months and Years</string>
	<string name="themes_fetching">Fetching themes…</string>
	<string name="stats_for">Stats for %s</string>
	<string name="stats_other_recent_stats_label">Other Recent Stats</string>
	<string name="stats_view_all">View all</string>
	<string name="stats_view">View</string>
	<string name="stats_followers_months">%1$d months</string>
	<string name="stats_followers_a_year">A year</string>
	<string name="stats_followers_years">%1$d years</string>
	<string name="stats_followers_a_month">A month</string>
	<string name="stats_followers_minutes">%1$d minutes</string>
	<string name="stats_followers_an_hour_ago">an hour ago</string>
	<string name="stats_followers_hours">%1$d hours</string>
	<string name="stats_followers_a_day">A day</string>
	<string name="stats_followers_days">%1$d days</string>
	<string name="stats_followers_a_minute_ago">a minute ago</string>
	<string name="stats_followers_seconds_ago">seconds ago</string>
	<string name="stats_followers_total_email">Total Email Followers: %1$s</string>
	<string name="stats_followers_wpcom_selector">WordPress.com</string>
	<string name="stats_followers_email_selector">Email</string>
	<string name="stats_followers_total_wpcom">Total WordPress.com Followers: %1$s</string>
	<string name="stats_comments_total_comments_followers">Total posts with comment followers: %1$s</string>
	<string name="stats_comments_by_authors">By Authors</string>
	<string name="stats_comments_by_posts_and_pages">By Posts &amp; Pages</string>
	<string name="stats_empty_followers_desc">Keep track of your overall number of followers, and how long each one has been following your site.</string>
	<string name="stats_empty_followers">No followers</string>
	<string name="stats_empty_publicize_desc">Keep track of your followers from various social networking services using publicise.</string>
	<string name="stats_empty_publicize">No publicise followers recorded</string>
	<string name="stats_empty_video">No videos played</string>
	<string name="stats_empty_video_desc">If you\'ve uploaded videos using VideoPress, find out how many times they’ve been watched.</string>
	<string name="stats_empty_comments_desc">If you allow comments on your site, track your top commenters and discover what content sparks the liveliest conversations, based on the most recent 1,000 comments.</string>
	<string name="stats_empty_tags_and_categories_desc">Get an overview of the most popular topics on your site, as reflected in your top posts from the past week.</string>
	<string name="stats_empty_top_authors_desc">Track the views on each contributor\'s posts, and zoom in to discover the most popular content by each author.</string>
	<string name="stats_empty_tags_and_categories">No tagged posts or pages viewed</string>
	<string name="stats_empty_clicks_desc">When your content includes links to other sites, you’ll see which ones your visitors click on the most.</string>
	<string name="stats_empty_referrers_desc">Learn more about your site’s visibility by looking at the websites and search engines that send the most traffic your way</string>
	<string name="stats_empty_clicks_title">No clicks recorded</string>
	<string name="stats_empty_referrers_title">No referrers recorded</string>
	<string name="stats_empty_top_posts_title">No posts or pages viewed</string>
	<string name="stats_empty_top_posts_desc">Discover what your most-viewed content is, and check how individual posts and pages perform over time.</string>
	<string name="stats_totals_followers">Since</string>
	<string name="stats_empty_geoviews">No countries recorded</string>
	<string name="stats_empty_geoviews_desc">Explore the list to see which countries and regions generate the most traffic to your site.</string>
	<string name="stats_entry_video_plays">Video</string>
	<string name="stats_entry_top_commenter">Author</string>
	<string name="stats_entry_publicize">Service</string>
	<string name="stats_entry_followers">Follower</string>
	<string name="stats_totals_publicize">Followers</string>
	<string name="stats_entry_clicks_link">Link</string>
	<string name="stats_view_top_posts_and_pages">Posts &amp; Pages</string>
	<string name="stats_view_videos">Videos</string>
	<string name="stats_view_publicize">Publicise</string>
	<string name="stats_view_followers">Followers</string>
	<string name="stats_view_countries">Countries</string>
	<string name="stats_likes">Likes</string>
	<string name="stats_pagination_label">Page %1$s of %2$s</string>
	<string name="stats_timeframe_years">Years</string>
	<string name="stats_views">Views</string>
	<string name="stats_visitors">Visitors</string>
	<string name="ssl_certificate_details">Details</string>
	<string name="delete_sure_post">Delete this post</string>
	<string name="delete_sure">Delete this draft</string>
	<string name="delete_sure_page">Delete this page</string>
	<string name="confirm_delete_multi_media">Delete selected items?</string>
	<string name="confirm_delete_media">Delete selected item?</string>
	<string name="cab_selected">%d selected</string>
	<string name="media_gallery_date_range">Displaying media from %1$s to %2$s</string>
	<string name="sure_to_remove_account">Remove this site?</string>
	<string name="reader_empty_followed_blogs_title">You\'re not following any sites yet</string>
	<string name="reader_empty_posts_liked">You haven\'t liked any posts</string>
	<string name="faq_button">FAQ</string>
	<string name="browse_our_faq_button">Browse our FAQ</string>
	<string name="nux_help_description">Visit the help centre to get answers to common questions or visit the forums to ask new ones</string>
	<string name="agree_terms_of_service">By creating an account you agree to the fascinating %1$sTerms of Service%2$s</string>
	<string name="create_new_blog_wpcom">Create WordPress.com blog</string>
	<string name="new_blog_wpcom_created">WordPress.com blog created!</string>
	<string name="reader_empty_comments">No comments yet</string>
	<string name="reader_empty_posts_in_tag">No posts with this tag</string>
	<string name="reader_label_comment_count_multi">%,d comments</string>
	<string name="reader_label_view_original">View original article</string>
	<string name="reader_label_like">Like</string>
	<string name="reader_label_liked_by">Liked By</string>
	<string name="reader_label_comment_count_single">One comment</string>
	<string name="reader_label_comments_closed">Comments are closed</string>
	<string name="reader_label_comments_on">Comments on</string>
	<string name="reader_title_photo_viewer">%1$d of %2$d</string>
	<string name="error_publish_empty_post">Can\'t publish an empty post</string>
	<string name="error_refresh_unauthorized_posts">You don\'t have permission to view or edit posts</string>
	<string name="error_refresh_unauthorized_pages">You don\'t have permission to view or edit pages</string>
	<string name="error_refresh_unauthorized_comments">You don\'t have permission to view or edit comments</string>
	<string name="older_month">Older than a month</string>
	<string name="more">More</string>
	<string name="older_two_days">Older than 2 days</string>
	<string name="older_last_week">Older than a week</string>
	<string name="stats_no_blog">Stats couldn\'t be loaded for the required blog</string>
	<string name="select_a_blog">Select a WordPress site</string>
	<string name="sending_content">Uploading %s content</string>
	<string name="uploading_total">Uploading %1$d of %2$d</string>
	<string name="mnu_comment_liked">Liked</string>
	<string name="comment">Comment</string>
	<string name="comment_trashed">Comment binned</string>
	<string name="posts_empty_list">No posts yet. Why not create one?</string>
	<string name="comment_reply_to_user">Reply to %s</string>
	<string name="pages_empty_list">No pages yet. Why not create one?</string>
	<string name="media_empty_list_custom_date">No media in this time interval</string>
	<string name="posting_post">Posting "%s"</string>
	<string name="signing_out">Signing out…</string>
	<string name="reader_toast_err_generic">Unable to perform this action</string>
	<string name="reader_toast_err_block_blog">Unable to block this blog</string>
	<string name="reader_toast_blog_blocked">Posts from this blog will no longer be shown</string>
	<string name="reader_menu_block_blog">Block this blog</string>
	<string name="contact_us">Contact us</string>
	<string name="hs__conversation_detail_error">Describe the problem you\'re seeing</string>
	<string name="hs__new_conversation_header">Support chat</string>
	<string name="hs__conversation_header">Support chat</string>
	<string name="hs__username_blank_error">Enter a valid name</string>
	<string name="hs__invalid_email_error">Enter a valid email address</string>
	<string name="add_location">Add location</string>
	<string name="current_location">Current location</string>
	<string name="search_location">Search</string>
	<string name="edit_location">Edit</string>
	<string name="search_current_location">Locate</string>
	<string name="preference_send_usage_stats">Send statistics</string>
	<string name="preference_send_usage_stats_summary">Automatically send usage statistics to help us improve WordPress for Android</string>
	<string name="update_verb">Update</string>
	<string name="schedule_verb">Schedule</string>
	<string name="reader_title_blog_preview">Reader Blog</string>
	<string name="reader_title_tag_preview">Reader Tag</string>
	<string name="reader_title_subs">Tags &amp; Blogs</string>
	<string name="reader_page_followed_tags">Followed tags</string>
	<string name="reader_page_followed_blogs">Followed sites</string>
	<string name="reader_hint_add_tag_or_url">Enter a URL or tag to follow</string>
	<string name="reader_label_followed_blog">Blog followed</string>
	<string name="reader_label_tag_preview">Posts tagged %s</string>
	<string name="reader_toast_err_get_blog_info">Unable to show this blog</string>
	<string name="reader_toast_err_already_follow_blog">You already follow this blog</string>
	<string name="reader_toast_err_follow_blog">Unable to follow this blog</string>
	<string name="reader_toast_err_unfollow_blog">Unable to unfollow this blog</string>
	<string name="reader_empty_recommended_blogs">No recommended blogs</string>
	<string name="saving">Saving…</string>
	<string name="media_empty_list">No media</string>
	<string name="ptr_tip_message">Tip: Pull down to refresh</string>
	<string name="help">Help</string>
	<string name="forgot_password">Lost your password?</string>
	<string name="forums">Forums</string>
	<string name="help_center">Help centre</string>
	<string name="ssl_certificate_error">Invalid SSL certificate</string>
	<string name="ssl_certificate_ask_trust">If you usually connect to this site without problems, this error could mean that someone is trying to impersonate the site, and you shouldn\'t continue. Would you like to trust the certificate anyway?</string>
	<string name="out_of_memory">Device out of memory</string>
	<string name="no_network_message">There is no network available</string>
	<string name="could_not_remove_account">Couldn\'t remove site</string>
	<string name="gallery_error">The media item couldn\'t be retrieved</string>
	<string name="blog_not_found">An error occurred when accessing this blog</string>
	<string name="wait_until_upload_completes">Wait until upload completes</string>
	<string name="theme_fetch_failed">Failed to fetch themes</string>
	<string name="theme_set_failed">Failed to set theme</string>
	<string name="theme_auth_error_message">Ensure you have the privilege to set themes</string>
	<string name="comments_empty_list">No comments</string>
	<string name="mnu_comment_unspam">Not spam</string>
	<string name="no_site_error">Couldn\'t connect to the WordPress site</string>
	<string name="adding_cat_failed">Adding category failed</string>
	<string name="adding_cat_success">Category added successfully</string>
	<string name="cat_name_required">The category name field is required</string>
	<string name="category_automatically_renamed">Category name %1$s isn\'t valid. It has been renamed to %2$s.</string>
	<string name="no_account">No WordPress account found, add an account and try again</string>
	<string name="sdcard_message">A mounted SD card is required to upload media</string>
	<string name="stats_empty_comments">No comments yet</string>
	<string name="stats_bar_graph_empty">No stats available</string>
	<string name="invalid_url_message">Check that the URL entered is valid</string>
	<string name="reply_failed">Reply failed</string>
	<string name="notifications_empty_list">No notifications</string>
	<string name="error_delete_post">An error occurred while deleting the %s</string>
	<string name="error_refresh_posts">Posts couldn\'t be refreshed at this time</string>
	<string name="error_refresh_pages">Pages couldn\'t be refreshed at this time</string>
	<string name="error_refresh_notifications">Notifications couldn\'t be refreshed at this time</string>
	<string name="error_refresh_comments">Comments couldn\'t be refreshed at this time</string>
	<string name="error_refresh_stats">Stats couldn\'t be refreshed at this time</string>
	<string name="error_generic">An error occurred</string>
	<string name="error_moderate_comment">An error occurred while moderating</string>
	<string name="error_edit_comment">An error occurred while editing the comment</string>
	<string name="error_upload">An error occurred while uploading the %s</string>
	<string name="error_load_comment">Couldn\'t load the comment</string>
	<string name="error_downloading_image">Error downloading image</string>
	<string name="passcode_wrong_passcode">Wrong PIN</string>
	<string name="invalid_email_message">Your email address isn\'t valid</string>
	<string name="invalid_password_message">Password must contain at least 4 characters</string>
	<string name="invalid_username_too_short">Username must be longer than 4 characters</string>
	<string name="invalid_username_too_long">Username must be shorter than 61 characters</string>
	<string name="username_only_lowercase_letters_and_numbers">Username can only contain lowercase letters (a-z) and numbers</string>
	<string name="username_required">Enter a username</string>
	<string name="username_not_allowed">Username not allowed</string>
	<string name="username_must_be_at_least_four_characters">Username must be at least 4 characters</string>
	<string name="username_contains_invalid_characters">Username may not contain the character “_”</string>
	<string name="username_must_include_letters">Username must have a least 1 letter (a-z)</string>
	<string name="email_invalid">Enter a valid email address</string>
	<string name="email_not_allowed">That email address isn\'t allowed</string>
	<string name="username_exists">That username already exists</string>
	<string name="email_exists">That email address is already being used</string>
	<string name="username_reserved_but_may_be_available">That username is currently reserved but may be available in a couple of days</string>
	<string name="blog_name_required">Enter a site address</string>
	<string name="blog_name_not_allowed">That site address isn\'t allowed</string>
	<string name="blog_name_must_be_at_least_four_characters">Site address must be at least 4 characters</string>
	<string name="blog_name_must_be_less_than_sixty_four_characters">The site address must be shorter than 64 characters</string>
	<string name="blog_name_contains_invalid_characters">Site address may not contain the character “_”</string>
	<string name="blog_name_cant_be_used">You may not use that site address</string>
	<string name="blog_name_only_lowercase_letters_and_numbers">Site address can only contain lowercase letters (a-z) and numbers</string>
	<string name="blog_name_exists">That site already exists</string>
	<string name="blog_name_reserved">That site is reserved</string>
	<string name="blog_name_reserved_but_may_be_available">That site is currently reserved but may be available in a couple days</string>
	<string name="username_or_password_incorrect">The username or password you entered is incorrect</string>
	<string name="nux_cannot_log_in">We can\'t log you in</string>
	<string name="xmlrpc_error">Couldn\'t connect. Enter the full path to xmlrpc.php on your site and try again.</string>
	<string name="select_categories">Select categories</string>
	<string name="account_details">Account details</string>
	<string name="edit_post">Edit post</string>
	<string name="add_comment">Add comment</string>
	<string name="connection_error">Connection error</string>
	<string name="cancel_edit">Cancel edit</string>
	<string name="scaled_image_error">Enter a valid scaled width value</string>
	<string name="post_not_found">An error occurred when loading the post. Refresh your posts and try again.</string>
	<string name="learn_more">Learn more</string>
	<string name="media_gallery_settings_title">Gallery settings</string>
	<string name="media_gallery_image_order">Image order</string>
	<string name="media_gallery_num_columns">Number of columns</string>
	<string name="media_gallery_type_thumbnail_grid">Thumbnail grid</string>
	<string name="media_gallery_edit">Edit gallery</string>
	<string name="media_error_no_permission">You don\'t have permission to view the media library</string>
	<string name="cannot_delete_multi_media_items">Some media can\'t be deleted at this time. Try again later.</string>
	<string name="themes_live_preview">Live preview</string>
	<string name="theme_current_theme">Current theme</string>
	<string name="theme_premium_theme">Premium theme</string>
	<string name="link_enter_url_text">Link text (optional)</string>
	<string name="create_a_link">Create a link</string>
	<string name="page_settings">Page settings</string>
	<string name="local_draft">Local draft</string>
	<string name="upload_failed">Upload failed</string>
	<string name="horizontal_alignment">Horizontal alignment</string>
	<string name="file_not_found">Couldn\'t find the media file for upload. Was it deleted or moved?</string>
	<string name="post_settings">Post settings</string>
	<string name="delete_post">Delete post</string>
	<string name="delete_page">Delete page</string>
	<string name="comment_status_approved">Approved</string>
	<string name="comment_status_unapproved">Pending</string>
	<string name="comment_status_spam">Spam</string>
	<string name="comment_status_trash">Binned</string>
	<string name="edit_comment">Edit comment</string>
	<string name="mnu_comment_approve">Approve</string>
	<string name="mnu_comment_unapprove">Unapprove</string>
	<string name="mnu_comment_spam">Spam</string>
	<string name="mnu_comment_trash">Bin</string>
	<string name="dlg_approving_comments">Approving</string>
	<string name="dlg_unapproving_comments">Unapproving</string>
	<string name="dlg_spamming_comments">Marking as spam</string>
	<string name="dlg_trashing_comments">Sending to bin</string>
	<string name="dlg_confirm_trash_comments">Send to bin?</string>
	<string name="trash_yes">Bin</string>
	<string name="trash_no">Don\'t bin</string>
	<string name="trash">Bin</string>
	<string name="author_name">Author name</string>
	<string name="author_email">Author email</string>
	<string name="author_url">Author URL</string>
	<string name="hint_comment_content">Comment</string>
	<string name="saving_changes">Saving changes</string>
	<string name="sure_to_cancel_edit_comment">Cancel editing this comment?</string>
	<string name="content_required">Comment is required</string>
	<string name="toast_comment_unedited">Comment hasn\'t changed</string>
	<string name="remove_account">Remove site</string>
	<string name="blog_removed_successfully">Site removed successfully</string>
	<string name="delete_draft">Delete draft</string>
	<string name="preview_page">Preview page</string>
	<string name="preview_post">Preview post</string>
	<string name="comment_added">Comment added successfully</string>
	<string name="post_not_published">Post status isn\'t published</string>
	<string name="page_not_published">Page status isn\'t published</string>
	<string name="view_in_browser">View in browser</string>
	<string name="add_new_category">Add new category</string>
	<string name="category_name">Category name</string>
	<string name="category_slug">Category slug (optional)</string>
	<string name="category_desc">Category description (optional)</string>
	<string name="category_parent">Category parent (optional):</string>
	<string name="share_action_post">New post</string>
	<string name="share_action_media">Media library</string>
	<string name="file_error_create">Couldn\'t create temp file for media upload. Make sure there is enough free space on your device.</string>
	<string name="location_not_found">Unknown location</string>
	<string name="open_source_licenses">Open source licenses</string>
	<string name="invalid_site_url_message">Check that the site URL entered is valid</string>
	<string name="pending_review">Pending review</string>
	<string name="http_credentials">HTTP credentials (optional)</string>
	<string name="http_authorization_required">Authorisation required</string>
	<string name="post_format">Post format</string>
	<string name="notifications_empty_all">No notifications…yet.</string>
	<string name="new_post">New post</string>
	<string name="new_media">New media</string>
	<string name="view_site">View site</string>
	<string name="privacy_policy">Privacy policy</string>
	<string name="local_changes">Local changes</string>
	<string name="image_settings">Image settings</string>
	<string name="add_account_blog_url">Blog address</string>
	<string name="wordpress_blog">WordPress blog</string>
	<string name="error_blog_hidden">This blog is hidden and couldn\'t be loaded. Enable it again in settings and try again.</string>
	<string name="fatal_db_error">An error occurred while creating the app database. Try reinstalling the app.</string>
	<string name="jetpack_message_not_admin">The Jetpack plugin is required for stats. Contact the site administrator.</string>
	<string name="reader_title_applog">Application log</string>
	<string name="reader_share_link">Share link</string>
	<string name="reader_toast_err_add_tag">Unable to add this tag</string>
	<string name="reader_toast_err_remove_tag">Unable to remove this tag</string>
	<string name="required_field">Required field</string>
	<string name="email_hint">Email address</string>
	<string name="site_address">Your self-hosted address (URL)</string>
	<string name="email_cant_be_used_to_signup">You can\'t use that email address to signup. We are having problems with them blocking some of our email. Use another email provider.</string>
	<string name="email_reserved">That email address has already been used. Check your inbox for an activation email. If you don\'t activate you can try again in a few days.</string>
	<string name="blog_name_must_include_letters">Site address must have at least 1 letter (a-z)</string>
	<string name="blog_name_invalid">Invalid site address</string>
	<string name="blog_title_invalid">Invalid site title</string>
	<string name="deleting_page">Deleting page</string>
	<string name="deleting_post">Deleting post</string>
	<string name="share_url_post">Share post</string>
	<string name="share_url_page">Share page</string>
	<string name="share_link">Share link</string>
	<string name="creating_your_account">Creating your account</string>
	<string name="creating_your_site">Creating your site</string>
	<string name="reader_empty_posts_in_tag_updating">Fetching posts…</string>
	<string name="error_refresh_media">Something went wrong while refreshing the media library. Try again later.</string>
	<string name="reader_likes_you_and_multi">You and %,d others like this</string>
	<string name="reader_likes_multi">%,d people like this</string>
	<string name="reader_toast_err_get_comment">Unable to retrieve this comment</string>
	<string name="reader_label_reply">Reply</string>
	<string name="video">Video</string>
	<string name="download">Downloading media</string>
	<string name="comment_spammed">Comment marked as spam</string>
	<string name="cant_share_no_visible_blog">You can\'t share to WordPress without a visible blog</string>
	<string name="select_time">Select time</string>
	<string name="reader_likes_you_and_one">You and one other like this</string>
	<string name="reader_empty_followed_blogs_description">But don\'t worry, just tap the icon at the top right to start exploring!</string>
	<string name="select_date">Select date</string>
	<string name="pick_photo">Select photo</string>
	<string name="account_two_step_auth_enabled">This account has two step authentication enabled. Visit your security settings on WordPress.com and generate an application-specific password.</string>
	<string name="pick_video">Select video</string>
	<string name="reader_toast_err_get_post">Unable to retrieve this post</string>
	<string name="validating_user_data">Validating user data</string>
	<string name="validating_site_data">Validating site data</string>
	<string name="password_invalid">You need a more secure password. Make sure to use 7 or more characters, mix uppercase and lowercase letters, numbers or special characters.</string>
	<string name="nux_tap_continue">Continue</string>
	<string name="nux_welcome_create_account">Create account</string>
	<string name="signing_in">Signing in…</string>
	<string name="nux_add_selfhosted_blog">Add self-hosted site</string>
	<string name="nux_oops_not_selfhosted_blog">Sign in to WordPress.com</string>
	<string name="media_add_popup_title">Add to media library</string>
	<string name="media_add_new_media_gallery">Create gallery</string>
	<string name="empty_list_default">This list is empty</string>
	<string name="select_from_media_library">Select from media library</string>
	<string name="jetpack_message">The Jetpack plugin is required for stats. Do you want to install Jetpack?</string>
	<string name="jetpack_not_found">Jetpack plugin not found</string>
	<string name="reader_untitled_post">(Untitled)</string>
	<string name="reader_share_subject">Shared from %s</string>
	<string name="reader_btn_share">Share</string>
	<string name="reader_btn_follow">Follow</string>
	<string name="reader_btn_unfollow">Following</string>
	<string name="reader_hint_comment_on_comment">Reply to comment…</string>
	<string name="reader_label_added_tag">Added %s</string>
	<string name="reader_label_removed_tag">Removed %s</string>
	<string name="reader_likes_one">One person likes this</string>
	<string name="reader_likes_only_you">You like this</string>
	<string name="reader_toast_err_comment_failed">Couldn\'t post your comment</string>
	<string name="reader_toast_err_tag_exists">You already follow this tag</string>
	<string name="reader_toast_err_tag_invalid">That isn\'t a valid tag</string>
	<string name="reader_toast_err_share_intent">Unable to share</string>
	<string name="reader_toast_err_view_image">Unable to view image</string>
	<string name="reader_toast_err_url_intent">Unable to open %s</string>
	<string name="reader_empty_followed_tags">You don\'t follow any tags</string>
	<string name="create_account_wpcom">Create an account on WordPress.com</string>
	<string name="button_next">Next</string>
	<string name="connecting_wpcom">Connecting to WordPress.com</string>
	<string name="username_invalid">Invalid username</string>
	<string name="limit_reached">Limit reached. You can try again in 1 minute. Trying again before that will only increase the time you have to wait before the ban is lifted. If you think this is in error, contact support.</string>
	<string name="nux_tutorial_get_started_title">Get started!</string>
	<string name="themes">Themes</string>
	<string name="all">All</string>
	<string name="images">Images</string>
	<string name="unattached">Unattached</string>
	<string name="custom_date">Custom Date</string>
	<string name="media_add_popup_capture_photo">Capture photo</string>
	<string name="media_add_popup_capture_video">Capture video</string>
	<string name="media_gallery_image_order_random">Random</string>
	<string name="media_gallery_image_order_reverse">Reverse</string>
	<string name="media_gallery_type">Type</string>
	<string name="media_gallery_type_squares">Squares</string>
	<string name="media_gallery_type_tiled">Tiled</string>
	<string name="media_gallery_type_circles">Circles</string>
	<string name="media_gallery_type_slideshow">Slideshow</string>
	<string name="media_edit_title_text">Title</string>
	<string name="media_edit_caption_text">Caption</string>
	<string name="media_edit_description_text">Description</string>
	<string name="media_edit_title_hint">Enter a title here</string>
	<string name="media_edit_caption_hint">Enter a caption here</string>
	<string name="media_edit_description_hint">Enter a description here</string>
	<string name="media_edit_success">Updated</string>
	<string name="media_edit_failure">Failed to update</string>
	<string name="themes_details_label">Details</string>
	<string name="themes_features_label">Features</string>
	<string name="theme_activate_button">Activate</string>
	<string name="theme_activating_button">Activating</string>
	<string name="theme_set_success">Successfully set theme!</string>
	<string name="theme_auth_error_title">Failed to fetch themes</string>
	<string name="post_excerpt">Excerpt</string>
	<string name="share_action_title">Add to …</string>
	<string name="share_action">Share</string>
	<string name="stats">Stats</string>
	<string name="stats_view_visitors_and_views">Visitors and Views</string>
	<string name="stats_view_clicks">Clicks</string>
	<string name="stats_view_tags_and_categories">Tags &amp; Categoriess</string>
	<string name="stats_view_referrers">Referrers</string>
	<string name="stats_timeframe_today">Today</string>
	<string name="stats_timeframe_yesterday">Yesterday</string>
	<string name="stats_timeframe_days">Days</string>
	<string name="stats_timeframe_weeks">Weeks</string>
	<string name="stats_timeframe_months">Months</string>
	<string name="stats_entry_country">Country</string>
	<string name="stats_entry_posts_and_pages">Title</string>
	<string name="stats_entry_tags_and_categories">Topic</string>
	<string name="stats_entry_authors">Author</string>
	<string name="stats_entry_referrers">Referrer</string>
	<string name="stats_totals_views">Views</string>
	<string name="stats_totals_clicks">Clicks</string>
	<string name="stats_totals_plays">Plays</string>
	<string name="passcode_manage">Manage PIN lock</string>
	<string name="passcode_enter_passcode">Enter your PIN</string>
	<string name="passcode_enter_old_passcode">Enter your old PIN</string>
	<string name="passcode_re_enter_passcode">Re-enter your PIN</string>
	<string name="passcode_change_passcode">Change PIN</string>
	<string name="passcode_set">PIN set</string>
	<string name="passcode_preference_title">PIN lock</string>
	<string name="passcode_turn_off">Turn PIN lock off</string>
	<string name="passcode_turn_on">Turn PIN lock on</string>
	<string name="upload">Upload</string>
	<string name="discard">Discard</string>
	<string name="sign_in">Sign in</string>
	<string name="notifications">Notifications</string>
	<string name="note_reply_successful">Reply published</string>
	<string name="follows">Follows</string>
	<string name="new_notifications">%d new notifications</string>
	<string name="more_notifications">and %d more.</string>
	<string name="loading">Loading…</string>
	<string name="httpuser">HTTP username</string>
	<string name="httppassword">HTTP password</string>
	<string name="error_media_upload">An error occurred while uploading media</string>
	<string name="post_content">Content (tap to add text and media)</string>
	<string name="publish_date">Publish</string>
	<string name="content_description_add_media">Add media</string>
	<string name="incorrect_credentials">Incorrect username or password.</string>
	<string name="password">Password</string>
	<string name="username">Username</string>
	<string name="reader">Reader</string>
	<string name="featured">Use as featured image</string>
	<string name="featured_in_post">Include image in post content</string>
	<string name="no_network_title">No network available</string>
	<string name="pages">Pages</string>
	<string name="caption">Caption (optional)</string>
	<string name="width">Width</string>
	<string name="posts">Posts</string>
	<string name="anonymous">Anonymous</string>
	<string name="page">Page</string>
	<string name="post">Post</string>
	<string name="blogusername">blogusername</string>
	<string name="ok">OK</string>
	<string name="upload_scaled_image">Upload and link to scaled image</string>
	<string name="scaled_image">Scaled image width</string>
	<string name="scheduled">Scheduled</string>
	<string name="link_enter_url">URL</string>
	<string name="uploading">Uploading…</string>
	<string name="version">Version</string>
	<string name="tos">Terms of Service</string>
	<string name="app_title">WordPress for Android</string>
	<string name="max_thumbnail_px_width">Default Image Width</string>
	<string name="image_alignment">Alignment</string>
	<string name="refresh">Refresh</string>
	<string name="untitled">Untitled</string>
	<string name="edit">Edit</string>
	<string name="post_id">Post</string>
	<string name="page_id">Page</string>
	<string name="post_password">Password (optional)</string>
	<string name="immediately">Immediately</string>
	<string name="quickpress_add_alert_title">Set shortcut name</string>
	<string name="today">Today</string>
	<string name="settings">Settings</string>
	<string name="share_url">Share URL</string>
	<string name="quickpress_window_title">Select blog for QuickPress shortcut</string>
	<string name="quickpress_add_error">Shortcut name can\'t be empty</string>
	<string name="publish_post">Publish</string>
	<string name="draft">Draft</string>
	<string name="post_private">Private</string>
	<string name="upload_full_size_image">Upload and link to full image</string>
	<string name="title">Title</string>
	<string name="tags_separate_with_commas">Tags (separate tags with commas)</string>
	<string name="categories">Categories</string>
	<string name="dlg_deleting_comments">Deleting comments</string>
	<string name="notification_blink">Blink notification light</string>
	<string name="notification_sound">Notification sound</string>
	<string name="notification_vibrate">Vibrate</string>
	<string name="status">Status</string>
	<string name="location">Location</string>
	<string name="sdcard_title">SD Card Required</string>
	<string name="select_video">Select a video from gallery</string>
	<string name="media">Media</string>
	<string name="delete">Delete</string>
	<string name="none">None</string>
	<string name="blogs">Blogs</string>
	<string name="select_photo">Select a photo from gallery</string>
	<string name="error">Error</string>
	<string name="cancel">Cancel</string>
	<string name="save">Save</string>
	<string name="add">Add</string>
	<string name="category_refresh_error">Category refresh error</string>
	<string name="preview">Preview</string>
	<string name="on">on</string>
	<string name="reply">Reply</string>
	<string name="notification_settings">Notification Settings</string>
	<string name="yes">Yes</string>
	<string name="no">No</string>
</resources>
