<?xml version="1.0" encoding="utf-8"?>
<resources>
	<string name="error_fetch_users_list">Cha b’ urrainn dhuinn cleachdaichean na làraich fhaighinn</string>
	<string name="plans_manage">Stiùirich am plana agad aig\nWordPress.com/plans</string>
	<string name="people_empty_list_filtered_viewers">Cha dug duine sam bith sùil air dad fhathast.</string>
	<string name="title_follower">Neach-leantainn</string>
	<string name="title_email_follower">Neach-leantainn puist-d</string>
	<string name="people_empty_list_filtered_email_followers">Chan eil duine sam bith ’gad leantainn fhathast slighe puist-d.</string>
	<string name="people_empty_list_filtered_followers">Chan eil duine sam bith ’gad leantainn fhathast.</string>
	<string name="people_empty_list_filtered_users">Chan eil cleachdaiche sam bith agad fhathast.</string>
	<string name="people_dropdown_item_email_followers">Luchd-leantainn puist-d</string>
	<string name="people_dropdown_item_viewers">Luchd-coimhid</string>
	<string name="people_dropdown_item_followers">Luchd-leantainn</string>
	<string name="people_dropdown_item_team">Sgioba</string>
	<string name="invite_message_usernames_limit">Thoir cuireadh do suas ri 10 puist-d agus/no ainmean-cleachdaichean WordPress.com. Mur eile ainm-cleachdaiche aig cuideigin, innsidh sinn dhaibh mar a gheibh iad fear.</string>
	<string name="viewer_remove_confirmation_message">Ma bheir thu air falbh an neach-coimhid seo, chan urrainn dhaibh tuilleadh tadhal air an làrach.\n\nA bheil thu airson a thoirt air falbh fhathast?</string>
	<string name="follower_remove_confirmation_message">Ma bheir thu an cleachdaiche seo air falbh, chan fhaigh iad brathan mun làrach seo tuilleadh ach ma nì iad leantainn às ùr.\n\nA bheil thu cinnteach gu bheil thu airson an neach-leantainn seo a thoirt air falbh?</string>
	<string name="follower_subscribed_since">A-mach o %1$s</string>
	<string name="reader_label_view_gallery">Seall an gailearaidh</string>
	<string name="error_remove_follower">Cha b’ urrainn dhuinn an neach-leantainn a thoirt air falbh</string>
	<string name="error_remove_viewer">Cha b’ urrainn dhuinn an neach-coimhid a thoirt air falbh</string>
	<string name="error_fetch_email_followers_list">Cha b’ urrainn dhuinn na daoine a leanas an làrach slighe puist-d fhaighinn</string>
	<string name="error_fetch_followers_list">Cha b’ urrainn dhuinn luchd-leantainn na làraich fhaighinn</string>
	<string name="editor_failed_uploads_switch_html">Cha deach gach meadhan a luchdadh suas. Chan urrainn dhut leum gun mhodh\n        HTML is cùisean mar seo. A bheil thu airson na dh’fhàillig a thoirt air falbh is leantainn air adhart?</string>
	<string name="format_bar_description_html">Am modh HTML</string>
	<string name="visual_editor">An deasaiche lèirsinneach</string>
	<string name="image_thumbnail">Dealbhagan deilbh</string>
	<string name="format_bar_description_ul">Liosta gun seòrsachadh</string>
	<string name="format_bar_description_ol">Liosta air a sheòrsachadh</string>
	<string name="format_bar_description_more">Cuir a-steach barrachd</string>
	<string name="format_bar_description_media">Am modh cuir a-steach</string>
	<string name="format_bar_description_strike">Loidhne troimhe</string>
	<string name="format_bar_description_quote">Bloc-luaidh</string>
	<string name="format_bar_description_link">Cuir a-steach ceangal</string>
	<string name="format_bar_description_italic">Eadailteach</string>
	<string name="format_bar_description_underline">Fo-loidhne</string>
	<string name="image_settings_save_toast">Chaidh na h-atharraichean a shàbhaladh</string>
	<string name="image_caption">Caipsean</string>
	<string name="image_alt_text">Roghainn teacsa</string>
	<string name="image_link_to">Ceangal ri</string>
	<string name="image_width">Leud</string>
	<string name="format_bar_description_bold">Trom</string>
	<string name="image_settings_dismiss_dialog_title">A bheil thu airson na h-atharraichean nach deach a shàbhaladh a thilgeil air falbh?</string>
	<string name="stop_upload_dialog_title">A bheil thu airson sgur dhen luchdadh suas?</string>
	<string name="stop_upload_button">Sguir dhen luchdadh suas</string>
	<string name="alert_error_adding_media">Thachair mearachd fhad ’s a bha sinn a’ cur a-steach a’ mheadhain</string>
	<string name="alert_action_while_uploading">Tha thu a’ luchdadh suas meadhanan. Fuirich ort gus am bi sin deiseil.</string>
	<string name="alert_insert_image_html_mode">Chan urrainn dhut meadhanan a chur a-steach mar sin sa mhodh HTML. Cleachd am modh lèirsinneach airson sin.</string>
	<string name="uploading_gallery_placeholder">A’ luchdadh suas a’ ghailearaidh…</string>
	<string name="invite_error_some_failed">Chaidh an cuireadh a chur ach thachair co-dhiù aon mhearachd!</string>
	<string name="invite_error_for_username">%1$s: %2$s</string>
	<string name="invite_sent">Chaidh an cuireadh a chur</string>
	<string name="tap_to_try_again">Thoir gnogag airson fheuchainn ris a-rithist!</string>
	<string name="invite_error_sending">Thachair mearachd nuair a dh’fheuch sinn ris an cuireadh a chur!</string>
	<string name="invite_error_invalid_usernames_multiple">Cha ghabh a chur: Tha ainmean no puist-d ann nach eil dligheach</string>
	<string name="invite_error_invalid_usernames_one">Cha ghabh a chur: Tha ainm no post-d ann nach eil dligheach</string>
	<string name="tabbar_accessibility_label_my_site">An làrach agam</string>
	<string name="tabbar_accessibility_label_me">Mise</string>
	<string name="editor_toast_changes_saved">Chaidh na h-atharraichean a shàbhaladh</string>
	<string name="passcodelock_prompt_message">Cuir a-steach am PIN agad</string>
	<string name="push_auth_expired">Dh’fhalbh an ùine air an iarrtas. Clàraich a-steach gu WordPress.com a dh’fheuchainn ris a-rithist.</string>
	<string name="stats_insights_most_popular_percent_views">%1$d%% de sheallaidhean</string>
	<string name="ignore">Leig seachad</string>
	<string name="stats_insights_best_ever">Na seallaidhean as fhearr a-riamh</string>
	<string name="stats_insights_most_popular_hour">An uair as fhèillmhoire</string>
	<string name="stats_insights_most_popular_day">An latha as fhèillmhoire</string>
	<string name="stats_insights_today">Stats an latha</string>
	<string name="stats_insights_popular">An latha ’s uair as fhèillmhoire</string>
	<string name="stats_insights_all_time">Puist, seallaidhean is aoighean air fad</string>
	<string name="stats_insights">Insights</string>
	<string name="stats_sign_in_jetpack_different_com_account">Clàraich a-steach gun chunntas WordPress.com leis an do cheangail thu Jetpack ris gus sùil a thoirt air na stats agad.</string>
	<string name="stats_other_recent_stats_moved_label">A bheil an corr dhe na stats a bha agad o chionn goirid a dhìth ort? Chaidh an gluasad gu duilleag nan Insights.</string>
	<string name="me_disconnect_from_wordpress_com">Dì-cheangail o WordPress.com</string>
	<string name="me_btn_login_logout">Clàraich a-steach/a-mach</string>
	<string name="me_connect_to_wordpress_com">Ceangail ri WordPress.com</string>
	<string name="me_btn_support">Cobhair ⁊ taic</string>
	<string name="site_picker_cant_hide_current_site">Cha deach “%s” a chur am falach a chionn ’s gur e sin an làrach làithreach</string>
	<string name="account_settings">Roghainnean a\' chunntais</string>
	<string name="site_picker_create_dotcom">Cruthaich làrach WordPress.com</string>
	<string name="site_picker_edit_visibility">Seall/falaich làraichean</string>
	<string name="site_picker_add_self_hosted">Cuir làrach air fèin-òstaireachd ris</string>
	<string name="site_picker_add_site">Cuir làrach ris</string>
	<string name="my_site_btn_view_admin">Seall an rianachd</string>
	<string name="my_site_btn_switch_site">Leum gu làrach eile</string>
	<string name="my_site_btn_view_site">Seall an làrach agam</string>
	<string name="site_picker_title">Tagh làrach</string>
	<string name="my_site_header_publish">Foillsich</string>
	<string name="my_site_header_look_and_feel">Coltas</string>
	<string name="my_site_btn_site_settings">Roghainnean</string>
	<string name="my_site_btn_blog_posts">Puist bloga</string>
	<string name="my_site_header_configuration">Rèiteachadh</string>
	<string name="reader_label_new_posts_subtitle">Thoir gnogag gus an sealltainn</string>
	<string name="notifications_account_required">Clàraich a-steach gu WordPress.com airson nam brathan</string>
	<string name="stats_unknown_author">Ùghdar neo-aithnichte</string>
	<string name="signout">Dì-cheangail</string>
	<string name="image_added">Chaidh an dealbh a chur ris</string>
	<string name="sign_out_wpcom_confirm">Ma dhì-cheanglas tu an cunntas agad, thèid an dàta WordPress.com air fad aig @%s a thoirt air falbh on uidheam seo, a’ gabhail a-steach dhreachdan is atharraichean ionadail.</string>
	<string name="select_all">Tagh na h-uile</string>
	<string name="hide">Falaich</string>
	<string name="show">Seall</string>
	<string name="deselect_all">Dì-thagh na h-uile</string>
	<string name="select_from_new_picker">Dèan ioma-thaghadh leis an roghnaichear ùr</string>
	<string name="no_media_sources">Cha b’ urrainn dhuinn na meadhanan fhaighinn</string>
	<string name="loading_blog_images">A’ faighinn nan dealbhan</string>
	<string name="loading_blog_videos">A’ faighinn nam videothan</string>
	<string name="error_loading_videos">Mearachd le luchdadh nan videothan</string>
	<string name="error_loading_images">Mearachd le luchdadh nan dealbhan</string>
	<string name="error_loading_blog_videos">Chan urrainn dhuinn na videothan fhaighinn</string>
	<string name="error_loading_blog_images">Chan urrainn dhuinn na dealbhan fhaighinn</string>
	<string name="no_blog_videos">Gun videothan</string>
	<string name="no_device_images">Gun dealbhan</string>
	<string name="no_device_videos">Gun videothan</string>
	<string name="no_blog_images">Gun dealbhan</string>
	<string name="stats_generic_error">Cha b’ urrainn dhuinn na stats a dh’iarr thu a luchdadh</string>
	<string name="no_media">Chan eil meadhanan ann</string>
	<string name="loading_images">A’ luchdadh nan dealbhan</string>
	<string name="loading_videos">A’ luchdadh nan videothan</string>
	<string name="sign_in_jetpack">Clàraich a-steach dhan chunntas WordPress.com agad airson ceangal ri Jetpack.</string>
	<string name="auth_required">Clàraich a-steach a-rithist airson leantainn air adhart.</string>
	<string name="two_step_sms_sent">Thoir sùil air na teachdaireachdan teacsa agad airson a’ chòd dearbhaidh.</string>
	<string name="two_step_footer_button">Cuir an còd slighe teachdaireachd teacsa</string>
	<string name="two_step_footer_label">Cuir a-steach on aplacaid dearbhaidh agad.</string>
	<string name="verify">Dearbh</string>
	<string name="invalid_verification_code">Còd dearbhadh mì-dhligheach</string>
	<string name="verification_code">Còd dearbhaidh</string>
	<string name="editor_toast_invalid_path">Tha slighe an fhaidhle mì-dhligheach</string>
	<string name="error_publish_no_network">Chan urrainn dhut foillseachadh mur eil ceangal ann. Chaidh dreachd dheth a shàbhaladh.</string>
	<string name="tab_title_site_videos">Videothan na làraich</string>
	<string name="tab_title_device_videos">Videothan an uidheim</string>
	<string name="tab_title_site_images">Dealbhan na làraich</string>
	<string name="take_video">Tog video</string>
	<string name="tab_title_device_images">Dealbhan an uidheim</string>
	<string name="take_photo">Tog dealbh</string>
	<string name="media_picker_title">Tagh meadhan</string>
	<string name="add_to_post">Cuir ris a’ phost</string>
	<string name="language">Cànan</string>
	<string name="device">Uidheam</string>
	<string name="media_details_label_file_name">Ainm an fhaidhle</string>
	<string name="media_details_label_file_type">Seòrsa an fhaidhle</string>
	<string name="media_fetching">A’ faighinn nam meadhanan…</string>
	<string name="posts_fetching">A’ faighinn nam post…</string>
	<string name="pages_fetching">A’ faighinn nan duilleagan…</string>
	<string name="toast_err_post_uploading">Cha ghabh post fhosgladh nuair a tha e ’ga luchdadh</string>
	<string name="stats_view_search_terms">Faclan-luirg</string>
	<string name="comments_fetching">A’ faighinn nam beachdan…</string>
	<string name="stats_entry_search_terms">Facal-luirg</string>
	<string name="stats_view_authors">Ùghdaran</string>
	<string name="stats_empty_search_terms">Cha deach facal-luirg sam bith a chlàradh</string>
	<string name="stats_empty_search_terms_desc">Fàs eòlach air trafaig nan lorg le bhith a’ toirt sùil air na faclan a lorg daoine ’s a thug iad dhan làrach agad.</string>
	<string name="stats_followers_total_wpcom_paged">A’ sealltainn %1$d - %2$d à %3$s luchd-leantainn WordPress.com</string>
	<string name="stats_followers_total_email_paged">A’ sealltainn %1$d - %2$d à %3$s luchd-leantainn puist-d</string>
	<string name="stats_search_terms_unknown_search_terms">Faclan-luirg nach aithnichear</string>
	<string name="publisher">Foillsichear:</string>
	<string name="error_notification_open">Cha b’ urrainn dhuinn am brath fhosgladh</string>
	<string name="reader_empty_posts_request_failed">Chan urrainn dhuinn na puist fhaighinn</string>
	<string name="stats_months_and_years">Mìosan is bliadhnaichean</string>
	<string name="stats_recent_weeks">Na seachdainean seo chaidh</string>
	<string name="error_copy_to_clipboard">Thachair mearachd nuair a chaidh lethbhreac dha na faidhlichean a chur air an stòr-bhòrd</string>
	<string name="stats_average_per_day">An cuibheas làitheil</string>
	<string name="reader_label_new_posts">Puist ùra</string>
	<string name="reader_empty_posts_in_blog">Tha am bloga seo falamh</string>
	<string name="stats_period">Ùine</string>
	<string name="logs_copied_to_clipboard">Chaidh lethbhreac de logaichean na h-aplacaid a chur air an stòr-bhòrd</string>
	<string name="stats_total">Iomlan</string>
	<string name="stats_overall">San fharsaingeachd</string>
	<string name="post_uploading">’Ga luchdadh suas</string>
	<string name="reader_page_recommended_blogs">Bidh ùidh agad sna leanas is dòcha</string>
	<string name="stats_comments_total_comments_followers">Puist air fad aig a bheil luchd-leantainn phost: %1$s</string>
	<string name="stats_visitors">Aoighean</string>
	<string name="stats_views">Seallaidhean</string>
	<string name="stats_pagination_label">Duilleag %1$s à %2$s</string>
	<string name="stats_timeframe_years">Bliadhna</string>
	<string name="stats_view_countries">Dùthchannan</string>
	<string name="stats_likes">Daoine as toil leotha</string>
	<string name="stats_view_followers">Luchd-leantainn</string>
	<string name="stats_entry_clicks_link">Ceangal</string>
	<string name="stats_view_top_posts_and_pages">Puist ⁊ duilleagan</string>
	<string name="stats_view_videos">Videothan</string>
	<string name="stats_view_publicize">Publicize</string>
	<string name="stats_entry_video_plays">Video</string>
	<string name="stats_entry_top_commenter">Ùghdar</string>
	<string name="stats_entry_publicize">Seirbheis</string>
	<string name="stats_entry_followers">Neach-leantainn</string>
	<string name="stats_totals_publicize">Luchd-leantainn</string>
	<string name="stats_empty_geoviews_desc">Fidir an liosta airson fiosrachadh dè na dùthchannan is roinnean-dùthcha on a thig an àireamh as motha de dhaoine thugad.</string>
	<string name="stats_totals_followers">A-mach o</string>
	<string name="stats_empty_geoviews">Cha deach dùthaich sam bith a chlàradh</string>
	<string name="stats_empty_clicks_title">Cha deach briogadh sam bith a chlàradh</string>
	<string name="stats_empty_referrers_title">Cha deach ath-threòraiche a chlàradh</string>
	<string name="stats_empty_top_posts_title">Cha deach coimhead air duilleag no post</string>
	<string name="stats_empty_top_posts_desc">Fiosraich dè an t-susbaint agad a tha mòran a’ coimhead air agus dè cho math ’s a tha puist is duilleagan àraidh a’ dèanamh thairis air ùine.</string>
	<string name="stats_empty_referrers_desc">Faigh barrachd fiosrachaidh air dè cho faicsinneach ’s a tha an làrach agad ’s tu a’ coimhead air na làraichean-lìn ’s na h-einnseanan-luirg on a thig mòran dhaoine</string>
	<string name="stats_empty_tags_and_categories">Cha deach coimhead air duilleag no post tagaichte</string>
	<string name="stats_empty_clicks_desc">Ma tha an t-susbaint agad a’ ceangal ri làraichean eile, chì thu dè an fheadhainn air am briog daoine as trice.</string>
	<string name="stats_empty_top_authors_desc">Cum sùil air co mheud duine a choimheadas air puist nan com-pàirtichean is fiosraich dè an t-susbaint air a bheil fèill mhòr aig gach ùghdar.</string>
	<string name="stats_empty_tags_and_categories_desc">Faigh foir-shealladh air na cuspairean air a bheil fèill mhòr air an làrach agad a-rèir nam post as trainge san t-seachdain seo chaidh.</string>
	<string name="stats_empty_comments_desc">Ma cheadaicheas tu beachdan air an làrach agad, ’s urrainn dhut sùil a chumail air cò na daoine a sgrìobhas an àireamh as motha de bheachdan agus dè an t-susbaint a bhrosnaicheas na deasbadan as beòthaile a-rèir a’ 1,000 beachd as ùire.</string>
	<string name="stats_empty_video_desc">Ma luchdaich thu suas videothan slighe VideoPress, faic co mheud turas a choimhead daoine orra.</string>
	<string name="stats_empty_video">Cha deach video a chluich</string>
	<string name="stats_empty_publicize">Cha deach neach-leantainn Publicize a chlàradh</string>
	<string name="stats_empty_publicize_desc">Cum sùil air cò tha ’gad leantainn o dhiofar sheirbheisean`sòisealta slighe Publicize.</string>
	<string name="stats_empty_followers">Gun luchd-leantainn</string>
	<string name="stats_empty_followers_desc">Cum sùil air co mheud neach-leantainn a tha agad san fharsaingeachd agus dè cho fad ’s a tha iad air a bhith ’nan luchd-leantainn agad.</string>
	<string name="stats_comments_by_posts_and_pages">A-rèir puist ⁊ duilleige</string>
	<string name="stats_comments_by_authors">A-rèir ùghdair</string>
	<string name="stats_followers_total_wpcom">Luchd-leantainn WordPress.com uile gu lèir: %1$s</string>
	<string name="stats_followers_email_selector">Post-d</string>
	<string name="stats_followers_wpcom_selector">WordPress.com</string>
	<string name="stats_followers_a_minute_ago">mionaid air ais</string>
	<string name="stats_followers_seconds_ago">diog(an) air ais</string>
	<string name="stats_followers_total_email">Luchd-leantainn puist-d uile gu lèir %1$s</string>
	<string name="stats_followers_days">%1$d là(ithean)</string>
	<string name="stats_followers_a_day">Latha</string>
	<string name="stats_followers_hours">%1$d uair(ean) a thìde</string>
	<string name="stats_followers_minutes">%1$d mionaid(ean)</string>
	<string name="stats_followers_an_hour_ago">uair a thìde air ais</string>
	<string name="stats_followers_a_month">Mìos</string>
	<string name="stats_followers_years">%1$d bliadhna</string>
	<string name="stats_view">Seall</string>
	<string name="stats_followers_months">%1$d mìos(an)</string>
	<string name="stats_followers_a_year">Bliadhna</string>
	<string name="stats_view_all">Seall na h-uile</string>
	<string name="stats_for">Na stats airson %s</string>
	<string name="stats_other_recent_stats_label">Stats ùra eile</string>
	<string name="themes_fetching">A’ faighinn nan ùrlaran…</string>
	<string name="ssl_certificate_details">Mion-fhiosrachadh</string>
	<string name="sure_to_remove_account">A bheil thu airson an làrach seo a thoirt air falbh?</string>
	<string name="media_gallery_date_range">A’ sealltainn nam meadhanan %1$s gu %2$s</string>
	<string name="cab_selected">%d air a thaghadh</string>
	<string name="confirm_delete_media">A bheil thu airson an rud a thagh thu a sguabadh às?</string>
	<string name="delete_sure">Sguab às an dreachd seo</string>
	<string name="delete_sure_page">Sguab às an duilleag seo</string>
	<string name="confirm_delete_multi_media">A bheil thu airson na rudan a thagh thu a sguabadh às?</string>
	<string name="delete_sure_post">Sguab às am post seo</string>
	<string name="signing_out">’Gad chlàradh a-mach…</string>
	<string name="posting_post">A’ postadh “%s”</string>
	<string name="media_empty_list_custom_date">Cha robh meadhan ann san eadaramh ùine seo</string>
	<string name="comment_trashed">Chaidh am beachd a chur dhan sgudal</string>
	<string name="posts_empty_list">Chan eil post agad fhathast. Carson nach cruthaich thu fear?</string>
	<string name="comment_reply_to_user">Freagair %s</string>
	<string name="pages_empty_list">Chan eil duilleag agad fhathast. Carson nach cruthaich thu tè?</string>
	<string name="mnu_comment_liked">’S toil leat seo</string>
	<string name="comment">Beachd</string>
	<string name="sending_content">A’ luchdadh suas susbaint %s</string>
	<string name="uploading_total">A’ luchdadh suas %1$d de %2$d</string>
	<string name="select_a_blog">Tagh làrach WordPress</string>
	<string name="stats_no_blog">Cha b’ urrainn dhuinn na stats aig a’ bhloga sin a luchdadh</string>
	<string name="older_last_week">Nas sine na seachdain</string>
	<string name="older_two_days">Nas sine na dà latha</string>
	<string name="older_month">Nas sine na mìos</string>
	<string name="error_refresh_unauthorized_comments">Chan eil cead agad coimhead beachdan fhaicinn no a dheasachadh</string>
	<string name="error_refresh_unauthorized_pages">Chan eil cead agad coimhead duilleagan fhaicinn no a dheasachadh</string>
	<string name="error_refresh_unauthorized_posts">Chan eil cead agad coimhead puist fhaicinn no a dheasachadh</string>
	<string name="error_publish_empty_post">Cha ghabh post bàn fhoillseachadh</string>
	<string name="reader_title_photo_viewer">%1$d de %2$d</string>
	<string name="reader_label_comments_on">Beachdan air</string>
	<string name="reader_label_comments_closed">Tha na beachdan dùinte</string>
	<string name="reader_label_comment_count_single">Aon bheachd</string>
	<string name="reader_label_like">’S toil</string>
	<string name="reader_label_view_original">Seall an t-artaigil tùsail</string>
	<string name="reader_label_comment_count_multi">%,d beachd(an)</string>
	<string name="reader_empty_posts_in_tag">Chan eil an taga seo aig post sam bith</string>
	<string name="reader_empty_comments">Chan eil beachd ann fhathast</string>
	<string name="create_new_blog_wpcom">Cruthaich bloga WordPress.com</string>
	<string name="new_blog_wpcom_created">Chaidh bloga WordPress.com a chruthachadh!</string>
	<string name="agree_terms_of_service">Ma chruthaicheas tu cunntas, bidh thu ag aontachadh ri %1$stermichean na seirbheise%2$s</string>
	<string name="nux_help_description">Tadhail air aonad na cobharach far am faigh thu freagairtean air ceistean cumanta no tadhail air na fòraman gus ceist ùr a chur.</string>
	<string name="browse_our_faq_button">Rùraich na CÀBHA agam</string>
	<string name="faq_button">CÀBHA</string>
	<string name="reader_empty_posts_liked">Cha duirt thu gur toil leat post sam bith fhathast</string>
	<string name="reader_empty_followed_blogs_title">Chan eil thu a’ leantainn làrach sam bith fhathast</string>
	<string name="more">Barrachd</string>
	<string name="reader_menu_block_blog">Bac am bloga seo</string>
	<string name="reader_toast_blog_blocked">Cha dèid puist on bhloga seo a shealltainn tuilleadh</string>
	<string name="reader_toast_err_block_blog">Cha ghabh am bloga seo a bhacadh</string>
	<string name="reader_toast_err_generic">Cha ghabh seo a dhèanamh</string>
	<string name="hs__invalid_email_error">Cuir a-steach post-d dligheach</string>
	<string name="hs__username_blank_error">Cuir a-steach ainm dligheach</string>
	<string name="hs__conversation_header">Cabadaich taice</string>
	<string name="hs__new_conversation_header">Cabadaich taice</string>
	<string name="hs__conversation_detail_error">Mìnich dè an duilgheadas a tha thu a’ faicinn</string>
	<string name="contact_us">Cuir fios thugainn</string>
	<string name="current_location">An t-ionad làithreach</string>
	<string name="add_location">Cuir ionad ris</string>
	<string name="search_current_location">Lorg</string>
	<string name="edit_location">Deasaich</string>
	<string name="search_location">Lorg</string>
	<string name="preference_send_usage_stats_summary">Cuir stats cleachdaidh thugainn ach an urrainn dhuinn WordPress airson Android a leasachadh</string>
	<string name="preference_send_usage_stats">Cuir na stats</string>
	<string name="schedule_verb">Cuir air an sgeideal</string>
	<string name="update_verb">Ùraich</string>
	<string name="reader_toast_err_already_follow_blog">Tha thu a’ leantainn a’ bhloga seo mu thràth</string>
	<string name="reader_toast_err_follow_blog">Cha ghabh am bloga seo a leantainn</string>
	<string name="reader_toast_err_unfollow_blog">Cha ghabh am bloga seo a dhì-leantainn</string>
	<string name="reader_empty_recommended_blogs">Chan eil bloga ann a mholamaid</string>
	<string name="reader_label_followed_blog">A’ leantainn a’ bhloga</string>
	<string name="reader_label_tag_preview">Puist ris a bheil taga %s</string>
	<string name="reader_toast_err_get_blog_info">Cha ghabh am bloga seo a shealltainn</string>
	<string name="reader_title_subs">Tagaichean ⁊ blogaichean</string>
	<string name="reader_page_followed_tags">Tagaichean a tha thu a’ leantainn</string>
	<string name="reader_title_blog_preview">Bloga leughadair</string>
	<string name="reader_title_tag_preview">Taga leughadair</string>
	<string name="reader_page_followed_blogs">Làraichean a tha thu a’ leantainn</string>
	<string name="reader_hint_add_tag_or_url">Cuir a-steach URL no taga gus a leantainn</string>
	<string name="media_empty_list">Chan eil meadhanan ann</string>
	<string name="ptr_tip_message">Gliocas: Tarraing a-nuas gus ath-nuadhachadh</string>
	<string name="saving">’Ga shàbhaladh…</string>
	<string name="ssl_certificate_ask_trust">Ma gheibh thu cothrom air an làrach seo gun duilgheadas sam bith a ghnàth, dh’fhaoidte gu bheil a’ mhearachd seo a’ ciallachadh gu bheil cuideigin a’ leigeil orra gur iad-san an làrach cheart is cha bu chòir dhut leantainn air adhart. A bheil thu airson gabhail ris an teisteanas co-dhiù?</string>
	<string name="forums">Fòraman</string>
	<string name="help_center">Aonad na cobharach</string>
	<string name="ssl_certificate_error">Teisteanas SSL mì-dhligheach</string>
	<string name="forgot_password">Na chaill thu am facal-faire agad?</string>
	<string name="help">Cobhair</string>
	<string name="nux_cannot_log_in">Chan urrainn dhuinn do chlàradh a-steach</string>
	<string name="username_or_password_incorrect">Tha an t-ainm-cleachdaiche no am facal-faire a chuir thu a-steach cearr</string>
	<string name="blog_name_reserved_but_may_be_available">Tha an làrach sin air a ghlèidheadh ach faodaidh gum bi e ri fhaighinn ann am beagan làithean</string>
	<string name="blog_name_reserved">Tha an làrach seo glèidhte aig cuideigin eile</string>
	<string name="blog_name_exists">Tha an làrach seo ann mu thràth</string>
	<string name="blog_name_only_lowercase_letters_and_numbers">Chan fhaod ach litrichean beaga (a-z) agus àireamhan a bhith ann an seòladh làraich</string>
	<string name="blog_name_cant_be_used">Chan urrainn dhut an seòladh làraich seo a chleachdadh</string>
	<string name="blog_name_must_be_less_than_sixty_four_characters">Feumaidh seòladh làraich a bhith nas giorra na 64 caractar</string>
	<string name="blog_name_contains_invalid_characters">Chan fhaod “_” a bhith ann an seòladh làraich</string>
	<string name="blog_name_must_be_at_least_four_characters">Feumaidh seòladh làraich a bhith 4 caractaran a dh’fhaid air a’ char as lugha</string>
	<string name="blog_name_not_allowed">Chan eil an seòladh làraich seo ceadaichte</string>
	<string name="blog_name_required">Cuir a-steach seòladh làraich</string>
	<string name="username_reserved_but_may_be_available">Tha an t-ainm-cleachdaiche sin air a chaomhnadh ach faodaidh gum bi e ri fhaighinn ann am beagan làithean</string>
	<string name="email_exists">Tha an seòladh puist-d sin ’ga chleachdadh mu thràth</string>
	<string name="email_invalid">Cuir a-steach post-d dligheach</string>
	<string name="email_not_allowed">Chan eil an seòladh puist-d seo ceadaichte</string>
	<string name="username_exists">Tha an t-ainm-cleachdaiche seo ann mu thràth</string>
	<string name="username_must_include_letters">Feumaidh co-dhiù aon litir (a-z) a bhith ann an ainm-cleachdaiche</string>
	<string name="username_must_be_at_least_four_characters">Feumaidh ainm cleachdaiche a bhith 4 caractaran a dh\'fhaid air a’ char as lugha</string>
	<string name="username_contains_invalid_characters">Chan fhaod “_” a bhith ann an ainm-cleachdaiche</string>
	<string name="username_not_allowed">Chan eil an t-ainm-cleachdaiche seo ceadaichte</string>
	<string name="invalid_username_too_long">Feumaidh ainm-cleachdaiche a bhith nas giorra na 61 caractar</string>
	<string name="username_only_lowercase_letters_and_numbers">Chan fhaod ach litrichean beaga (a-z) agus àireamhan a bhith ann an ainm-cleachdaiche</string>
	<string name="username_required">Cuir a-steach ainm-cleachdaiche</string>
	<string name="invalid_username_too_short">Feumaidh ainm-cleachdaiche a bhith nas fhaide na 4 caractaran</string>
	<string name="invalid_password_message">Feumaidh facal-faire a bhith 4 caractaran a dh’fhaid air a’ char as lugha</string>
	<string name="invalid_email_message">Chan eil am post-d agad dligheach</string>
	<string name="passcode_wrong_passcode">PIN cearr</string>
	<string name="error_downloading_image">Mearachd le luchdadh a-nuas an deilbh</string>
	<string name="error_load_comment">Cha b’ urrainn dhuinn am beachd a luchdadh</string>
	<string name="error_refresh_comments">Cha b’ urrainn dhuinn na beachdan ath-nuadhachadh aig an àm seo</string>
	<string name="error_refresh_stats">Cha b’ urrainn dhuinn na stats ath-nuadhachadh aig an àm seo</string>
	<string name="error_generic">Thachair mearachd</string>
	<string name="error_moderate_comment">Thachair mearachd fhad \'s a bha sinn ri modarataireachd</string>
	<string name="error_edit_comment">Thachair mearachd rè deasachadh a’ bheachd</string>
	<string name="error_upload">Thachair mearachd fhad ’s a bha sinn a’ luchdadh suas %s</string>
	<string name="notifications_empty_list">Gun bhrathan</string>
	<string name="error_delete_post">Thachair mearachd fhad ’s a bhathar a’ sguabadh às %s</string>
	<string name="error_refresh_posts">Cha b’ urrainn dhuinn na puist ath-nuadhachadh aig an àm seo</string>
	<string name="error_refresh_pages">Cha b’ urrainn dhuinn na duilleagan ath-nuadhachadh aig an àm seo</string>
	<string name="error_refresh_notifications">Cha b’ urrainn dhuinn na brathan ath-nuadhachadh aig an àm seo</string>
	<string name="reply_failed">Dh’fhàillig an fhreagairt</string>
	<string name="stats_empty_comments">Chan eil beachd ann fhathast</string>
	<string name="stats_bar_graph_empty">Chan eil stats ri fhaighinn</string>
	<string name="sdcard_message">Feumaidh tu cairt SD a chaidh a mhunntachadh mus urrainn dhut meadhanan a luchdadh suas</string>
	<string name="category_automatically_renamed">Chan e ainm dligheach airson roinn-seòrsa a tha ann an %1$s. Chaidh %2$s a chur air an àite sin.</string>
	<string name="no_account">Cha deach cunntas WordPress a lorg, cuir cunntas ris is feuch ris a-rithist</string>
	<string name="cat_name_required">Tha feum air raon ainm na roinn-seòrsa</string>
	<string name="adding_cat_success">Chaidh an roinn-seòrsa a chur ris</string>
	<string name="adding_cat_failed">Dh’fhàillig cur ris na roinn-seòrsa</string>
	<string name="no_site_error">Cha b’ urrainn dhuinn ceangal ri làrach WordPress</string>
	<string name="theme_set_failed">Cha b’ urrainn dhuinn an t-ùrlar a shuidheachadh</string>
	<string name="theme_auth_error_message">Dèan cinnteach gu bheil cead agad ùrlaran a shuidheachadh</string>
	<string name="comments_empty_list">Gun bheachdan</string>
	<string name="mnu_comment_unspam">Beachd còir</string>
	<string name="gallery_error">Cha b’ urrainn dhuinn am meadhan fhaighinn</string>
	<string name="blog_not_found">Thachair mearachd fhad ’s a bha sinn ag inntrigeadh a’ bhloga seo</string>
	<string name="wait_until_upload_completes">Fuirich ort gus an deach a luchdadh suas</string>
	<string name="theme_fetch_failed">Cha b’ urrainn dhuinn na h-ùrlaran fhaighinn dhut</string>
	<string name="out_of_memory">Chan eil cuimhne air fhàgail air an uidheam</string>
	<string name="no_network_message">Chan eil lìonra ri làimh</string>
	<string name="could_not_remove_account">Cha b’ urrainn dhuinn an làrach a thoirt air falbh</string>
	<string name="invalid_url_message">Dèan cinnteach gu bheil an URL seo dligheach</string>
	<string name="blog_title_invalid">Tiotal làraich mì-dhligheach</string>
	<string name="blog_name_must_include_letters">Feumaidh co-dhiù aon litir (a-z) a bhith ann an seòladh làraich</string>
	<string name="blog_name_invalid">Seòladh làraich mì-dhligheach</string>
	<string name="email_reserved">Chaidh am post-d sin a chleachdadh mu thràth. Thoir sùil aig a’ bhogsa phuist agad ach a bheil post-d ann gus a chur an gnìomh. Cha bhi e ri fhaighinn tuilleadh ann am beagan làithean mura dèan thu dad.</string>
	<string name="email_cant_be_used_to_signup">Chan urrainn dhut am post-d sin a chleachdadh gus clàradh. Tha fhios againn gu bheil duilgheadas ann ’s iad a cur casg air cuid dhen phost-d againn. Saoil an cleachd thu solaraiche puist-d eile?</string>
	<string name="email_hint">Seòladh puist-d</string>
	<string name="site_address">Seòladh na fèin-òstaireachd agad (URL)</string>
	<string name="required_field">Raon air a bheil feum</string>
	<string name="reader_toast_err_add_tag">Cha ghabh an taga seo a chur ris</string>
	<string name="reader_toast_err_remove_tag">Cha ghabh an taga seo a thoirt air falbh</string>
	<string name="reader_share_link">Co-roinn an ceangal</string>
	<string name="jetpack_message_not_admin">Tha feum air plugan Jetpack mu choinneamh nan stats. Cuir fios gu rianaire na làraich.</string>
	<string name="reader_title_applog">Loga na h-aplacaid</string>
	<string name="fatal_db_error">Thachair mearachd fhad ’s a bha sinn a’ cruthachadh stòr-dàta nan aplacaidean. Feuch is stàlaich an aplacaid às ùr.</string>
	<string name="error_blog_hidden">’S e bloga falaichte a tha ann is cha b’ urrainn dhuinn a luchdadh. Cuir an comas e sna roghainnean is feuch ris a-rithist.</string>
	<string name="wordpress_blog">Bloga WordPress</string>
	<string name="add_account_blog_url">Seòladh a’ bhloga</string>
	<string name="local_changes">Atharraichean ionadail</string>
	<string name="image_settings">Roghainnean an deilbh</string>
	<string name="privacy_policy">Am poileasaidh prìobhaideachd</string>
	<string name="view_site">Seall an làrach agam</string>
	<string name="new_media">Meadhan ùr</string>
	<string name="new_post">Post ùr</string>
	<string name="post_format">Fòrmat a’ phuist</string>
	<string name="http_authorization_required">Tha feum air ùghdarrasadh</string>
	<string name="pending_review">Ri lèirmheasadh</string>
	<string name="http_credentials">Ainm ’s facal-faire HTTP (roghainneil)</string>
	<string name="open_source_licenses">Ceadachasan Open Source</string>
	<string name="location_not_found">Seòladh neo-aithnichte</string>
	<string name="file_error_create">Cha b’ urrainn dhuinn am faidhle sealach a chruthachadh gus meadhan a luchdadh suas. Dèan cinnteach gu bheil rum gu leòr air an uidheam agad.</string>
	<string name="share_action_post">Post ùr</string>
	<string name="share_action_media">Leabhar-lann nam meadhanan</string>
	<string name="category_parent">Pàrant na roinn-seòrsa (roghainneil):</string>
	<string name="category_desc">Tuairisgeul na roinn-seòrsa (roghainneil)</string>
	<string name="category_slug">Sluga na roinn-seòrsa (roghainneil)</string>
	<string name="category_name">Ainm na roinne-seòrsa</string>
	<string name="add_new_category">Cuir roinn-seòrsa ùr ris</string>
	<string name="view_in_browser">Seall sa bhrabhsair</string>
	<string name="page_not_published">Cha deach staid na duilleige fhoillseachadh</string>
	<string name="post_not_published">Cha deach staid a’ phuist fhoillseachadh</string>
	<string name="comment_added">Chaidh am beachd a chur ris</string>
	<string name="preview_post">Ro-sheall am post</string>
	<string name="preview_page">Ro-sheall an duilleag</string>
	<string name="delete_draft">Sguab às an dreachd</string>
	<string name="blog_removed_successfully">Chaidh an làrach a thoirt air falbh</string>
	<string name="remove_account">Thoir air falbh an làrach</string>
	<string name="author_email">Post-d an ùghdair</string>
	<string name="author_url">URl an ùghdair</string>
	<string name="hint_comment_content">Beachd</string>
	<string name="saving_changes">A’ sàbhaladh nan atharrachadh</string>
	<string name="sure_to_cancel_edit_comment">A bheil thu airson sgur de dheasachadh a’ bheachd seo?</string>
	<string name="content_required">Tha feum air beachd</string>
	<string name="toast_comment_unedited">Cha deach am beachd atharrachadh</string>
	<string name="author_name">Ainm an ùghdair</string>
	<string name="trash">An sgudal</string>
	<string name="trash_no">Na cuir</string>
	<string name="trash_yes">Cuir</string>
	<string name="dlg_confirm_trash_comments">Cuir dhan sgudal?</string>
	<string name="dlg_trashing_comments">’Ga chur dhan sgudal</string>
	<string name="dlg_approving_comments">’Ga aontachadh</string>
	<string name="dlg_unapproving_comments">A’ toirt air falbh an t-aonta</string>
	<string name="dlg_spamming_comments">A’ cur comharra gur e spama a tha ann</string>
	<string name="mnu_comment_spam">Spama</string>
	<string name="mnu_comment_trash">Sgudal</string>
	<string name="mnu_comment_approve">Aontaich ris</string>
	<string name="mnu_comment_unapprove">Thoir air falbh an t-aonta</string>
	<string name="comment_status_trash">San sgudal</string>
	<string name="edit_comment">Deasaich am beachd</string>
	<string name="comment_status_unapproved">Ri dhèanamh</string>
	<string name="comment_status_spam">Spama</string>
	<string name="comment_status_approved">Air aontachadh</string>
	<string name="delete_page">Sguab às an duilleag</string>
	<string name="delete_post">Sguab às am post</string>
	<string name="horizontal_alignment">Co-thaobhadh còmhnard</string>
	<string name="file_not_found">Cha b’ urrainn dhuinn greim fhaighinn air faidhle a’ mheadhain gus a luchdadh suas. An deach a sguabadh às no a ghluasad?</string>
	<string name="post_settings">Roghainnean a’ phuist</string>
	<string name="local_draft">Dreachd ionadail</string>
	<string name="upload_failed">Dh’fhàillig a luchdadh suas</string>
	<string name="page_settings">Roghainnean na duilleige</string>
	<string name="create_a_link">Cruthaich ceangal</string>
	<string name="theme_premium_theme">Ùrlar Premium</string>
	<string name="link_enter_url_text">Teacsa a’ cheangail (roghainneil)</string>
	<string name="themes_live_preview">Ro-shealladh beò</string>
	<string name="theme_current_theme">An t-ùrlar làithreach</string>
	<string name="cannot_delete_multi_media_items">Tha meadhanan ann ach gabh an sguabadh às an-dràsta fhèin. Feuch ris a-rithist an ceann greis.</string>
	<string name="media_error_no_permission">Chan eil cead agad coimhead air leabhar-lann nam meadhanan</string>
	<string name="media_gallery_type_thumbnail_grid">Griod nan dealbhagan</string>
	<string name="media_gallery_edit">Deasaich an gailearaidh</string>
	<string name="media_gallery_settings_title">Roghainnean a’ ghailearaidh</string>
	<string name="media_gallery_image_order">Òrdugh nan dealbhan</string>
	<string name="media_gallery_num_columns">Àireamh de cholbhan</string>
	<string name="post_not_found">Thachair mearachd rè luchdadh a’ phuist. Ath-nuadhaich na puist is feuch ris a-rithist.</string>
	<string name="learn_more">Barrachd fiosrachaidh</string>
	<string name="scaled_image_error">Cuir a-steach luach sgèileadh leud dligheach</string>
	<string name="connection_error">Mearachd leis a’ cheangal</string>
	<string name="cancel_edit">Sguir dhen deasachadh</string>
	<string name="select_categories">Tagh roinnean-seòrsa</string>
	<string name="account_details">Fiosrachadh a’ chunntais</string>
	<string name="edit_post">Deasaich am post</string>
	<string name="add_comment">Cuir beachd ris</string>
	<string name="xmlrpc_error">Cha b’ urrainn dhuinn ceangal a dhèanamh. Cuir a-steach an t-slighe shlàn gun xmlrpc.php air an làrach agad is feuch ris a-rithist.</string>
	<string name="invalid_site_url_message">Dèan cinnteach gu bheil an URL a chuir thu a-steach dligheach</string>
	<string name="notifications_empty_all">Chan eil brath ann… fhathast.</string>
	<string name="share_link">Co-roinn an ceangal</string>
	<string name="deleting_page">A’ sguabadh às na duilleige</string>
	<string name="deleting_post">A’ sguabadh às a’ phuist</string>
	<string name="share_url_post">Co-roinn am post</string>
	<string name="share_url_page">Co-roinn an duilleag</string>
	<string name="creating_your_account">A\' cruthachadh a\' chunntais agad</string>
	<string name="creating_your_site">A\' cruthachadh na làraich agad</string>
	<string name="reader_empty_posts_in_tag_updating">A\' faighinn nam post...</string>
	<string name="error_refresh_media">Chaidh rudeigin cearr fhad \'s a bha sinn ag ath-nuadhachadh leabhar-lann nam meadhanan. Feuch ris a-rithist an ceann greis.</string>
	<string name="reader_likes_you_and_multi">Thuirt thusa agus %,d eile gur toigh leibh seo</string>
	<string name="reader_likes_multi">\'S toigh le %,d daoine seo</string>
	<string name="reader_toast_err_get_comment">Chan urrainn dhuinn am beachd seo fhaighinn dhut</string>
	<string name="reader_label_reply">Freagair</string>
	<string name="video">Video</string>
	<string name="download">A\' luchdadh a-nuas a\' mheadhain</string>
	<string name="comment_spammed">Chaidh comharra spama a chur ris a\' bheachd</string>
	<string name="cant_share_no_visible_blog">Chan urrainn dhut co-roinneadh gu WordPress as aonais bloga a tha ri fhaicinn</string>
	<string name="select_time">Tagh àm</string>
	<string name="reader_likes_you_and_one">Thuirt thusa agus aonan eile gur toigh leibh seo</string>
	<string name="select_date">Tagh ceann-là</string>
	<string name="pick_photo">Tagh dealbh</string>
	<string name="account_two_step_auth_enabled">Tha dearbhadh dà-cheumnach an sàs sa chunntas seo. Tadhail air na roghainnean tèarainteachd agad air WordPress.com agus gin facal-faire gu sònraichte dhan aplacaid.</string>
	<string name="pick_video">Tagh video</string>
	<string name="reader_toast_err_get_post">Chan urrainn dhuinn am post seo fhaighinn dhut</string>
	<string name="validating_user_data">A\' dearbhadh dàta a\' chleachdaiche</string>
	<string name="validating_site_data">A\' dearbhadh dàta na làraich</string>
	<string name="reader_empty_followed_blogs_description">Ach na gabh dragh, cha leig thu leas ach gnogag a thoirt air a ìomhaigheag gu h-àrd air an taobh deas gus an rùrachadh!</string>
	<string name="password_invalid">Feumaidh tu facal-faire nas tèarainte. Dèan cinnteach gun cleachd thu co-dhiù 7 caractaran, measgachadh de litrichean mòra \'s beaga, àireamhan is caractaran sònraichte.</string>
	<string name="nux_tap_continue">Air adhart</string>
	<string name="nux_welcome_create_account">Cruthaich cunntas</string>
	<string name="nux_add_selfhosted_blog">Cuir làrach air fèin-òstaireachd ris</string>
	<string name="nux_oops_not_selfhosted_blog">\'Gad chlàradh a-steach gu WordPress.com</string>
	<string name="signing_in">’Gad chlàradh a-steach…</string>
	<string name="media_add_popup_title">Cuir ri leabharlann nam meadhanan</string>
	<string name="media_add_new_media_gallery">Cruthaich gailearaidh</string>
	<string name="select_from_media_library">Tagh o leabhar-lann nam meadhanan</string>
	<string name="jetpack_message">Tha feum air plugan Jetpack mus fhaigh thu na stats. A bheil thu airson Jetpack a stàladh?</string>
	<string name="jetpack_not_found">Cha deach am plugan Jetpack a lorg</string>
	<string name="reader_untitled_post">(Gun tiotal)</string>
	<string name="reader_share_subject">Air a cho-roinneadh o %s</string>
	<string name="reader_btn_share">Co-roinn</string>
	<string name="reader_btn_follow">Lean</string>
	<string name="reader_btn_unfollow">A\' leanntainn</string>
	<string name="reader_label_added_tag">Chaidh %s a chur ris</string>
	<string name="reader_label_removed_tag">Chaidh %s a thoirt air falbh</string>
	<string name="reader_likes_one">Tha aon duine ag ràdh gur toigh leotha seo</string>
	<string name="reader_likes_only_you">\'S toigh leat seo</string>
	<string name="reader_toast_err_comment_failed">Cha b\' urrainn dhuinn do bheachd a phostadh</string>
	<string name="reader_toast_err_tag_exists">Tha thu a\' leantainn an taga seo mu thràth</string>
	<string name="reader_toast_err_tag_invalid">Cha e taga dligheach a tha seo</string>
	<string name="reader_toast_err_share_intent">Cha ghabh a cho-roinneadh</string>
	<string name="reader_toast_err_view_image">Cha ghabh an dealbh seo a shealltainn</string>
	<string name="reader_toast_err_url_intent">Cha ghabh %s fhosgladh</string>
	<string name="connecting_wpcom">A\' ceangal ri WordPress.com</string>
	<string name="username_invalid">Ainm-cleachdaiche mì-dhligheach</string>
	<string name="limit_reached">Chleachd thu na tha ceadaichte dhut. Feuch ris a-rithist ann am mionaid. Ma dh\'fheuchas tu ris roimhe sin, fàsaidh an ùine mus dèid an toirmeasg a thoirt dhìot. Ma tha thu dhen bheachd gur e mearachd a tha seo, cuir fios gun sgioba taice.</string>
	<string name="nux_tutorial_get_started_title">Toiseach tòiseachaidh!</string>
	<string name="create_account_wpcom">Cruthaich cunntas air WordPress.com</string>
	<string name="reader_empty_followed_tags">Chan eil thu a’ leantainn taga sam bith</string>
	<string name="empty_list_default">Tha an liosta seo falamh</string>
	<string name="reader_hint_comment_on_comment">Freagair am beachd…</string>
	<string name="button_next">Air adhart</string>
	<string name="themes">Ùrlaran</string>
	<string name="all">Na h-uile</string>
	<string name="images">Dealbhan</string>
	<string name="unattached">Gun cheangal ris</string>
	<string name="custom_date">Ceann-là gnàthaichte</string>
	<string name="media_add_popup_capture_photo">Tog dealbh</string>
	<string name="media_add_popup_capture_video">Tog video</string>
	<string name="media_gallery_image_order_random">Air thuaiream</string>
	<string name="media_gallery_image_order_reverse">Òrdugh contrarra</string>
	<string name="media_gallery_type">Seòrsa</string>
	<string name="media_gallery_type_squares">Ceàrnagan</string>
	<string name="media_gallery_type_tiled">Mar leacan</string>
	<string name="media_gallery_type_circles">Cearcallan</string>
	<string name="media_gallery_type_slideshow">Taisbeanadh-shleamhnagan</string>
	<string name="media_edit_title_text">Tiotal</string>
	<string name="media_edit_caption_text">Caipsean</string>
	<string name="media_edit_description_text">Tuairisgeul</string>
	<string name="media_edit_title_hint">Cuir tiotal an-seo</string>
	<string name="media_edit_caption_hint">Cuir caipsean an-seo</string>
	<string name="media_edit_description_hint">Cuir tuairisgeul an-seo</string>
	<string name="media_edit_success">Air ùrachadh</string>
	<string name="media_edit_failure">Dh\'fhàillig an t-ùrachadh</string>
	<string name="themes_details_label">Mion-fhiosrachadh</string>
	<string name="themes_features_label">Feartan</string>
	<string name="theme_activate_button">Cuir an gnìomh</string>
	<string name="theme_activating_button">\'Ga ghnìomhachadh</string>
	<string name="theme_set_success">Chaidh an t-ùrlar a shuidheachadh!</string>
	<string name="theme_auth_error_title">Cha b\' urrainn dhuinn na h-ùrlaran fhaighinn dhut</string>
	<string name="post_excerpt">Às-earrann</string>
	<string name="share_action_title">Cuir ri ...</string>
	<string name="share_action">Co-roinn</string>
	<string name="stats">Stats</string>
	<string name="stats_view_clicks">Briogaidhean</string>
	<string name="stats_view_tags_and_categories">Tagaichean ⁊ roinnean-seòrsa</string>
	<string name="stats_view_referrers">Ath-threòraichean</string>
	<string name="stats_timeframe_today">An-diugh</string>
	<string name="stats_timeframe_yesterday">An-dè</string>
	<string name="stats_timeframe_days">Làithean</string>
	<string name="stats_timeframe_weeks">Seachdainean</string>
	<string name="stats_timeframe_months">Mìosan</string>
	<string name="stats_entry_country">Dùthaich</string>
	<string name="stats_entry_posts_and_pages">Tiotal</string>
	<string name="stats_entry_tags_and_categories">Cuspair</string>
	<string name="stats_entry_authors">Ùghdar</string>
	<string name="stats_entry_referrers">Ath-threòraiche</string>
	<string name="stats_view_visitors_and_views">Aoighean is na choimheadadh</string>
	<string name="stats_totals_views">Seallaidhean</string>
	<string name="stats_totals_clicks">Briogaidhean</string>
	<string name="stats_totals_plays">Air a chluich</string>
	<string name="passcode_enter_passcode">Cuir a-steach am PIN agad</string>
	<string name="passcode_re_enter_passcode">Cuir a-steach am PIN agad a-rithist</string>
	<string name="passcode_change_passcode">Atharraich am PIN</string>
	<string name="passcode_manage">Stiùirich glas a\' PIN</string>
	<string name="passcode_enter_old_passcode">Cuir a-steach an seann PIN agad</string>
	<string name="passcode_set">Chaidh am PIN a shuidheachadh</string>
	<string name="passcode_preference_title">Glas a\' PIN</string>
	<string name="passcode_turn_off">Cuir glas a\' PIN dheth</string>
	<string name="passcode_turn_on">Cuir glas a\' PIN air</string>
	<string name="upload">Luchdadh suas</string>
	<string name="discard">Tilg air falbh</string>
	<string name="sign_in">Clàraich a-steach</string>
	<string name="notifications">Brathan</string>
	<string name="note_reply_successful">Chaidh an fhreagairt fhoillseachadh</string>
	<string name="new_notifications">%d brath(an) ùra</string>
	<string name="more_notifications">agus %d a bharrachd.</string>
	<string name="follows">Daoine a lean</string>
	<string name="loading">\'Ga luchdadh…</string>
	<string name="httpuser">Ainm-cleachdaiche HTTP</string>
	<string name="httppassword">Facal-faire HTTP</string>
	<string name="error_media_upload">Thachair mearachd fhad \'s a bha sinn a\' luchdadh suas meadhan</string>
	<string name="post_content">Susbaint (thoir gnogag gus teacsa \'s meadhanan a chur ris)</string>
	<string name="publish_date">Foillsich</string>
	<string name="content_description_add_media">Cuir meadhan ris</string>
	<string name="incorrect_credentials">Ainm-cleachdaiche no facal-faire cearr.</string>
	<string name="password">Facal-faire</string>
	<string name="username">Ainm-cleachdaiche</string>
	<string name="reader">Leughadair</string>
	<string name="featured">Cleachd mar dhealbh brosnaichte</string>
	<string name="featured_in_post">Gabh a-steach an dealbh ann an susbaint a\' phuist</string>
	<string name="no_network_title">Chan eil lìonra ri fhaighinn</string>
	<string name="pages">Duilleagan</string>
	<string name="caption">Caipsean (roghainneil)</string>
	<string name="width">Leud</string>
	<string name="posts">Puist</string>
	<string name="anonymous">Gun urra</string>
	<string name="page">Duilleag</string>
	<string name="post">Post</string>
	<string name="blogusername">ainm cleachdaiche a\' bhloga</string>
	<string name="ok">Ceart ma-thà</string>
	<string name="upload_scaled_image">Luchdaich suas is dèan ceangal ris an dealbh sgèilichte</string>
	<string name="scaled_image">Leud an deilbh sgèilichte</string>
	<string name="scheduled">Air an sgeideal</string>
	<string name="link_enter_url">URL</string>
	<string name="uploading">’Ga luchdadh suas…</string>
	<string name="version">Tionndadh</string>
	<string name="tos">Teirmichean na seirbheise</string>
	<string name="app_title">WordPress airson Android</string>
	<string name="max_thumbnail_px_width">Leud bunaiteach an deilbh</string>
	<string name="image_alignment">Co-thaobhadh</string>
	<string name="refresh">Ath-nuadhaich</string>
	<string name="untitled">Gun tiotal</string>
	<string name="edit">Deasaich</string>
	<string name="post_id">Post</string>
	<string name="page_id">Duilleag</string>
	<string name="post_password">Facal-faire (roghainneil)</string>
	<string name="immediately">Sa bhad</string>
	<string name="quickpress_add_alert_title">Suidhich ainm na h-ath-ghoirid</string>
	<string name="today">An-diugh</string>
	<string name="settings">Roghainnean</string>
	<string name="share_url">Co-roinn an URL</string>
	<string name="quickpress_window_title">Tagh bloga airson ath-ghoirid QuickPress</string>
	<string name="quickpress_add_error">Chan fhaod ainm na h-ath-ghoirid a bhith bàn</string>
	<string name="publish_post">Foillsich</string>
	<string name="draft">Dreachd</string>
	<string name="post_private">Prìobhaideach</string>
	<string name="upload_full_size_image">Luchdaich suas is dèan ceangal ris an dealbh slàn</string>
	<string name="title">Tiotal</string>
	<string name="tags_separate_with_commas">Tagaichean (sgar na tagaichean le cromagan)</string>
	<string name="categories">Roinnean-seòrsa</string>
	<string name="dlg_deleting_comments">A’ sguabadh às nam beachdan</string>
	<string name="notification_blink">Boillsg solas</string>
	<string name="notification_vibrate">Crith</string>
	<string name="notification_sound">Fuaim bhrathan</string>
	<string name="status">Staid</string>
	<string name="location">Ionad</string>
	<string name="sdcard_title">Tha feum air cairt SD</string>
	<string name="select_video">Tagh video on ghailearaidh</string>
	<string name="media">Meadhan</string>
	<string name="delete">Sguab às</string>
	<string name="none">Chan eil gin</string>
	<string name="blogs">Blogaichean</string>
	<string name="select_photo">Tagh dealbh on ghailearaidh</string>
	<string name="error">Mearachd</string>
	<string name="cancel">Sguir dheth</string>
	<string name="save">Sàbhail</string>
	<string name="add">Cuir ris</string>
	<string name="preview">Ro-shealladh</string>
	<string name="on"> </string>
	<string name="reply">Freagair</string>
	<string name="yes">Tha</string>
	<string name="no">Chan eil</string>
	<string name="category_refresh_error">Mearachd le ath-nuadhachadh na roinn-seòrsa</string>
	<string name="notification_settings">Roghainnean nam brathan</string>
</resources>
