<?xml version="1.0" encoding="utf-8"?>
<resources>
	<string name="editor_failed_uploads_switch_html">Mae rhai lwythi cyfryngau wedi methu. Nid oes modd newid i\'r modd HTML\n       yn y cyflwr hwn. Tynnu pob cyfrwng sydd wedi methu a pharhau?</string>
	<string name="format_bar_description_html">Modd HTML</string>
	<string name="visual_editor">Golygydd gweledol</string>
	<string name="image_thumbnail">Llun bach delwedd</string>
	<string name="format_bar_description_ul">Rhestr heb ei drefnu</string>
	<string name="format_bar_description_ol">Rhestr wedi\'i drefnu</string>
	<string name="format_bar_description_more">Mewnosod rhagor</string>
	<string name="format_bar_description_media">Mewnosod cyfrwng</string>
	<string name="format_bar_description_strike">Llinell Drwodd</string>
	<string name="format_bar_description_quote">Dyfyniad bloc</string>
	<string name="format_bar_description_link">Mewnosod dolen</string>
	<string name="format_bar_description_italic">Italig</string>
	<string name="format_bar_description_underline">Tanlinellu</string>
	<string name="image_settings_save_toast">Mae\'r newidiadau wedi eu cadw</string>
	<string name="image_caption">Egluryn</string>
	<string name="image_alt_text">Testun Amgen</string>
	<string name="image_link_to">Cyswllt i</string>
	<string name="image_width">Lled</string>
	<string name="format_bar_description_bold">Trwm</string>
	<string name="image_settings_dismiss_dialog_title">Dileu\'r newidiadau heb eu cadw?</string>
	<string name="stop_upload_dialog_title">Atal y llwytho?</string>
	<string name="stop_upload_button">Atal y Llwytho</string>
	<string name="alert_error_adding_media">Digwyddodd gwall wrth fewnosod y cyfrwng</string>
	<string name="alert_action_while_uploading">Rydych wrthi\'n llwytho cyfrwng. Arhoswch nes i hyn orffen.</string>
	<string name="alert_insert_image_html_mode">Nid oes modd mewnosod y cyfrwng yn uniongyrchol yn y modd HTML.Ewch i\'r modd gweledol</string>
	<string name="uploading_gallery_placeholder">Llwytho\'r oriel...</string>
	<string name="invite_sent">wedi anfon gwahoddiad yn llwyddiannus</string>
	<string name="tap_to_try_again">Tapiwch i geisio eto!</string>
	<string name="invite_message_info">(Dewisol) Gallwch gynnwys neges bersonol o hyd at 500 nod a fydd yn cael ei gynnwys yn y gwahoddiad i\'r defnyddiwr.</string>
	<string name="invite_message_remaining_other">%d nod yn weddill</string>
	<string name="invite_message_remaining_one">1 nod yn weddill</string>
	<string name="invite_message_remaining_zero">0 nod yn weddill</string>
	<string name="invite_invalid_email">Nid yw\'r cyfeiriad \'%s\' yn ddilys</string>
	<string name="invite_message_title">Neges Bersonol</string>
	<string name="invite_already_a_member">Mae yna eisoes aelod sy\'n defnyddio\'r enw defnyddiwr \'%s\'</string>
	<string name="invite_username_not_found">Nid oes defnyddiwr yn defnyddio\'r enw \'%s\'</string>
	<string name="invite">Gwahodd</string>
	<string name="invite_names_title">Enwau defnyddwyr neu E-byst</string>
	<string name="signup_succeed_signin_failed">Mae eich cyfrif wedi ei greu ond bu gwall wrth i ni eich mewngofnodi\n      Ceisiwch fewngofnodi gyda\'ch enw defnyddiwr a chyfrinair newydd.</string>
	<string name="send_link">Anfon dolen</string>
	<string name="my_site_header_external">Allanol</string>
	<string name="invite_people">Gwahodd Pobl</string>
	<string name="label_clear_search_history">Clirio hanes chwilio</string>
	<string name="dlg_confirm_clear_search_history">Clirio hanes chwilio?</string>
	<string name="reader_empty_posts_in_search_description">Dim cofnodion gan %s yn eich iaith</string>
	<string name="reader_label_post_search_running">Chwilio…</string>
	<string name="reader_label_related_posts">Darllen Perthnasol</string>
	<string name="reader_empty_posts_in_search_title">Heb ganfod unrhyw gofnod</string>
	<string name="reader_label_post_search_explainer">Chwilio pob blog WordPress.com gyhoeddus</string>
	<string name="reader_hint_post_search">Chwilio WordPress.com</string>
	<string name="reader_title_related_post_detail">Cofnodion Perthnasol</string>
	<string name="reader_title_search_results">Chwilio am %s</string>
	<string name="preview_screen_links_disabled">Mae dolenni wedi eu hanalluogi ar y sgrin rhagolwg</string>
	<string name="draft_explainer">Mae\'r cofnod yn ddrafft sydd heb ei gyhoeddi</string>
	<string name="send">Anfon</string>
	<string name="person_remove_confirmation_title">Tynnu %1$s</string>
	<string name="reader_empty_posts_in_custom_list">Nid yw\'r gwefannau ar y rhestr hon wedi cofnodi dim yn ddiweddar</string>
	<string name="people">Pobl</string>
	<string name="edit_user">Golygu Defnyddiwr</string>
	<string name="role">Rôl</string>
	<string name="error_remove_user">Methu tynnu defnyddiwr</string>
	<string name="error_update_role">Methu diweddaru rôl defnyddiwr</string>
	<string name="gravatar_camera_and_media_permission_required">Y caniatâd sydd eu hange i ddewis neu gipio llun</string>
	<string name="error_updating_gravatar">Gwall wrth ddiweddaru eich Gravatar</string>
	<string name="error_locating_image">Gwall wrth ganfod y ddelwedd wedi ei thocio</string>
	<string name="error_refreshing_gravatar">Gwall wrth ail-lwytho eich Gravatar</string>
	<string name="gravatar_tip">Newydd! Tapiwch eich Gravatar i\'w newid!</string>
	<string name="error_cropping_image">Bu gwall wrth docio eich delwedd.</string>
	<string name="launch_your_email_app">Cychwyn eich rhaglen e-bost</string>
	<string name="checking_email">Gwirio e-bost</string>
	<string name="not_on_wordpress_com">Nid ar WordPress.com?</string>
	<string name="magic_link_unavailable_error_message">Ddim ar gael ar hyn o bryd. Rhowch eich cyfrinair</string>
	<string name="check_your_email">Gwiriwch eich e-bost</string>
	<string name="get_a_link_sent_to_your_email_to_sign_in_instantly">Derbyn dolen wedi ei anfon at eich e-bost er mwyn mewngofnodi\'n syth</string>
	<string name="logging_in">Mewngofnodi</string>
	<string name="enter_your_password_instead">Rhowch eich cyfrinair yn hytrach</string>
	<string name="web_address_dialog_hint">Dangos yn gyhoeddus pan fyddwch yn gwneud sylw</string>
	<string name="jetpack_not_connected_message">Mae\'r ategyn Jetpack wedi\'i osod, ond heb ei gysylltu â WordPress.com. Ydych chi am gysylltu Jetpack?</string>
	<string name="username_email">E-bost neu enw defnyddiwr</string>
	<string name="jetpack_not_connected">Nid yw\'r ategyn jetpack wedi ei gysylltu</string>
	<string name="new_editor_reflection_error">Nid yw\'r golygydd gweledol yn gydnaws â\'ch dyfais. Cafodd\n         ei analluogi\'n awtomatig.</string>
	<string name="stats_insights_latest_post_no_title">(dim teit)</string>
	<string name="capture_or_pick_photo">Cipio neu ddewis llun</string>
	<string name="plans_post_purchase_text_themes">Mae gennych nawr fynediad diderfyn i themâu Premiwm. Er mwyn cychwyn arni, gallwch gael rhagolwg o unrhyw thema ar eich gwefan.</string>
	<string name="plans_post_purchase_button_themes">Pori\'r Themâu</string>
	<string name="plans_post_purchase_title_themes">Canfod y thema Premiwm perffaith</string>
	<string name="plans_post_purchase_button_video">Cychwyn cofnod newydd</string>
	<string name="plans_post_purchase_text_video">Gallwch lwytho a lletya fideos ar eich gwefan gyda VideoPress a\'ch storio cyfryngau ehangach.</string>
	<string name="plans_post_purchase_title_video">Bywiogwch eich cofnodion gyda fideo</string>
	<string name="plans_post_purchase_button_customize">Cyfaddasu eich Gwefan</string>
	<string name="plans_post_purchase_text_customize">Bellach mae gennych fynediad i ffontiau,  lliwiau a galluoedd  golygu CSS.</string>
	<string name="plans_post_purchase_text_intro">Mae eich gwefan yn llawn cyffro! Ewch i archwilio nodweddion newydd eich gwefan a dewis be i ddechrau.</string>
	<string name="plans_post_purchase_title_customize">Cyfaddasu Ffontiau a Lliwiau</string>
	<string name="plans_post_purchase_title_intro">Chi bia hwn nawr, i ffwrdd â chi!</string>
	<string name="export_your_content_message">Bydd cofnodion, tudalennau a gosodiadau yn cael eu e-bost atoch i %s.</string>
	<string name="plan">Cynllun</string>
	<string name="plans">Cynlluniau</string>
	<string name="plans_loading_error">Methu llwytho cynlluniau</string>
	<string name="export_your_content">Allforio eich cynnwys</string>
	<string name="exporting_content_progress">Allforio cynnwys…</string>
	<string name="export_email_sent">Anfonwyd yr e-bost allforio!</string>
	<string name="premium_upgrades_message">Mae gennych uwchraddiadau premiwm gweithredol ar eich gwefan. Diddymwch eich uwchraddiadau cyn dileu eich gwefan.</string>
	<string name="show_purchases">Dangos y nwyddau â brynwyd</string>
	<string name="checking_purchases">Gwirio\'r nwyddau â brynwyd</string>
	<string name="premium_upgrades_title">Uwchraddiadau Premiwm</string>
	<string name="purchases_request_error">Aeth rhywbeth o\'i le. Methu prynu nwyddau.</string>
	<string name="delete_site_progress">Wrthi\'n dileu gwefan…</string>
	<string name="delete_site_summary">Nid oes modd dadwneud y weithred hon. Bydd dileu\'r eich gwefan yn cael gwared ar yr holl gynnwys, cyfranwyr, a pharthau\'r wefan.</string>
	<string name="delete_site_hint">Dileu\'r wefan</string>
	<string name="export_site_hint">Allforio eich gwefan i ffeil XML</string>
	<string name="are_you_sure">Ydych chi\'n Siŵr?</string>
	<string name="export_site_summary">Os ydych yn siŵr, cymrwch eich amser ac allforio eich cynnwys nawr. Ni fydd modd ei adfer yn y dyfodol.</string>
	<string name="keep_your_content">Cadw Eich Cynnwys</string>
	<string name="domain_removal_hint">Ni fydd y parth yn gweithio unwaith y dilëwch eich gwefan</string>
	<string name="domain_removal_summary">Byddwch yn ofalus! Bydd dileu eich gwefan hefyd yn dileu\'r eich parth(au), isod.</string>
	<string name="primary_domain">Prif Barth</string>
	<string name="domain_removal">Tynnu\'r Parth</string>
	<string name="error_deleting_site_summary">Bu gwall wrth ddileu\'r wefan. Cysylltwch a\'n gwasanaeth cymorth am gymorth pellach</string>
	<string name="error_deleting_site">Gwall wrth ddileu\'r wefan</string>
	<string name="confirm_delete_site_prompt">Teipiwch %1$s yn y maes isod i gadarnhau. Wedyn, bydd eich  gwefan wedi mynd am byth.</string>
	<string name="site_settings_export_content_title">Allforio cynnwys</string>
	<string name="contact_support">Cysylltu â\'n cefnogaeth</string>
	<string name="confirm_delete_site">Cadarnhau Dileu Gwefan</string>
	<string name="start_over_text">Os ydych eisiau gwefan ond dim o\'r cofnodion a thudalennau sydd gennych ar hyn o bryd gall ein tîm cymorth ddileu eich cofnodion, tudalennau, cyfryngau, a sylwadau ar eich cyfer.\n\nBydd hyn yn cadw eich gwefan ac URL byw, ond yn rhoi dechrau newydd i\'ch creu cynnwys. Cysylltwch â ni i ni gael clirio eich cynnwys cyfredol.</string>
	<string name="site_settings_start_over_hint">Cychwyn eich gwefan eto</string>
	<string name="let_us_help">Gadewch i ni Helpu</string>
	<string name="me_btn_app_settings">Gosodiadau Apiau</string>
	<string name="start_over">Cychwyn Eto</string>
	<string name="editor_remove_failed_uploads">Tynnu llwythi sydd wedi methu</string>
	<string name="editor_toast_failed_uploads">Mae rhai lwythi cyfryngau wedi methu. Nid oes modd cadw na chyhoeddi\n       eich cofnod yn y cyflwr hwn. Hoffech chi dynnu pob cyfrwng sydd wedi methu?</string>
	<string name="comments_empty_list_filtered_trashed">Dim sylwadau yn y Sbwriel</string>
	<string name="site_settings_advanced_header">Uwch</string>
	<string name="comments_empty_list_filtered_pending">Dim sylwadau o Dan Ystyriaeth</string>
	<string name="comments_empty_list_filtered_approved">Dim sylwadau Cymeradwy</string>
	<string name="button_done">Gorffen</string>
	<string name="button_skip">Hepgor</string>
	<string name="site_timeout_error">Methwyd cysylltu â gwefan WordPress oherwydd gwall Terfyn Amser.</string>
	<string name="xmlrpc_malformed_response_error">Doedd dim modd cysylltu. Ymatebodd y gosodiad WordPress gyda dogfen XML-RPC annilys.</string>
	<string name="xmlrpc_missing_method_error">Doedd dim modd cysylltu. Mae\'r dulliau XML-RPC angenrheidiol ar goll o\'r gweinydd.</string>
	<string name="post_format_status">Statws</string>
	<string name="post_format_video">Fideo</string>
	<string name="theme_free">Rhad ac am Ddim</string>
	<string name="theme_all">Y Cyfan</string>
	<string name="theme_premium">Premiwm</string>
	<string name="post_format_chat">Sgwrs</string>
	<string name="post_format_gallery">Oriel</string>
	<string name="post_format_image">Delwedd</string>
	<string name="post_format_link">Dolen</string>
	<string name="post_format_quote">Dyfyniad</string>
	<string name="post_format_standard">Safonol</string>
	<string name="notif_events">Gwybodaeth am gyrsiau a digwyddiadau WordPress.com (ar-lein a byw).</string>
	<string name="post_format_aside">Neilleb</string>
	<string name="post_format_audio">Sain</string>
	<string name="notif_surveys">Cyfleoedd i gymryd rhan mewn ymchwil a holiaduron WordPress.com.</string>
	<string name="notif_tips">Awgrymiadau ar sut i gael y gorau o WordPress.com.</string>
	<string name="notif_community">Cymuned</string>
	<string name="replies_to_my_comments">Atebion i fy sylwadau</string>
	<string name="notif_suggestions">Awgrymiadau</string>
	<string name="notif_research">Ymchwil</string>
	<string name="site_achievements">Llwyddiannau\'r wefan</string>
	<string name="username_mentions">Cyfeiriadau gan yr enw defnyddiwr</string>
	<string name="likes_on_my_posts">Hoffi fy nghofnodion</string>
	<string name="site_follows">Mae\'r wefan yn dilyn</string>
	<string name="likes_on_my_comments">Hoffi fy sylwadau</string>
	<string name="comments_on_my_site">Sylwadau ar fy ngwefan</string>
	<string name="site_settings_list_editor_summary_other">%d eitem</string>
	<string name="site_settings_list_editor_summary_one">1 eitem</string>
	<string name="approve_auto_if_previously_approved">Sylwadau defnyddwyr hysbys</string>
	<string name="approve_auto">Pob defnyddiwr</string>
	<string name="approve_manual">Dim sylwadau</string>
	<string name="site_settings_paging_summary_other">%d sylw i\'r dudalen</string>
	<string name="site_settings_paging_summary_one">1 sylw i\'r dudalen</string>
	<string name="site_settings_multiple_links_summary_other">Angen cymeradwyaeth ar gyfer mwy na %d dolen</string>
	<string name="site_settings_multiple_links_summary_one">Angen cymeradwyaeth ar gyfer mwy nag 1 dolen</string>
	<string name="site_settings_multiple_links_summary_zero">Angen cymeradwyaeth ar gyfer mwy na 0 dolen</string>
	<string name="detail_approve_auto">Cymeradwyo sylwadau pawb yn awtomatig.</string>
	<string name="detail_approve_auto_if_previously_approved">Cymeradwyo\'n awtomatig os yw\'r defnyddiwr eisoes wedi cymeradwyo sylw</string>
	<string name="detail_approve_manual">Angen cymeradwyaeth â llaw ar gyfer sylwadau pawb.</string>
	<string name="filter_trashed_posts">Yn y Sbwriel</string>
	<string name="days_quantity_one">1 diwrnod</string>
	<string name="days_quantity_other">%d diwrnod</string>
	<string name="filter_published_posts">Cyhoeddwyd</string>
	<string name="filter_draft_posts">Drafftiau</string>
	<string name="filter_scheduled_posts">Amserlenwyd</string>
	<string name="pending_email_change_snackbar">Cliciwch ar y ddolen dilysu yn yr e-bost a anfonwyd at i%1$s i gadarnhau eich cyfeiriad newydd</string>
	<string name="primary_site">Prif wefan</string>
	<string name="web_address">Cyfeiriad Gwe</string>
	<string name="editor_toast_uploading_please_wait">Rydych wrthi\'n llwytho cyfryngau. Arhoswch nes i hyn orffen.</string>
	<string name="error_refresh_comments_showing_older">Nid oes modd adnewyddu sylwadau ar hyn o bryd - yn dangos sylwadau hŷn</string>
	<string name="editor_post_settings_set_featured_image">Gosod Delwedd Nodwedd</string>
	<string name="editor_post_settings_featured_image">Delwedd Nodwedd</string>
	<string name="new_editor_promo_desc">Mae\'r ap WordPress Android bellach yn cynnwys golygydd  gweledol\n  newydd hardd. Rhowch gynnig arno drwy greu cofnod newydd.</string>
	<string name="new_editor_promo_title">Golygydd newydd sbon</string>
	<string name="new_editor_promo_button_label">Gwych, diolch!</string>
	<string name="visual_editor_enabled">Galluogwyd y Golygydd Gweledol</string>
	<string name="editor_content_placeholder">Rhanwch eich stori yma…</string>
	<string name="editor_page_title_placeholder">Teitl Tudalen</string>
	<string name="editor_post_title_placeholder">Teitl Cofnod</string>
	<string name="email_address">Cyfeiriad e-bost</string>
	<string name="preference_show_visual_editor">Dangos y golygydd gweledol</string>
	<string name="dlg_sure_to_delete_comments">Dileu\'r sylwadau hyn yn barhaol?</string>
	<string name="preference_editor">Golygydd</string>
	<string name="dlg_sure_to_delete_comment">Dileu\'r sylwadau hyn yn barhaol?</string>
	<string name="mnu_comment_delete_permanently">Dileu</string>
	<string name="comment_deleted_permanently">Wedi dileu\'r sylw</string>
	<string name="mnu_comment_untrash">Adfer</string>
	<string name="comments_empty_list_filtered_spam">Dim sylwadau Sbam</string>
	<string name="could_not_load_page">Methu llwytho\'r dudalen</string>
	<string name="comment_status_all">Y Cyfan</string>
	<string name="interface_language">Iaith y Rhyngwyneb</string>
	<string name="off">Diffodd</string>
	<string name="about_the_app">Am yr ap</string>
	<string name="error_post_account_settings">Nid oedd modd cadw manylion eich cyfrif</string>
	<string name="error_post_my_profile">Nid oedd modd cadw eich proffil</string>
	<string name="error_fetch_account_settings">Methu adfer gosodiadau eich cyfrif</string>
	<string name="error_fetch_my_profile">Methu adfer eich proffil</string>
	<string name="stats_widget_promo_ok_btn_label">Iawn, rwy\'n ei ddeall</string>
	<string name="stats_widget_promo_desc">Ychwanegwch y teclyn i\'ch sgrin cartref er mwyn cael mynediad at eich Ystadegau mewn un clic.</string>
	<string name="stats_widget_promo_title">Teclyn Ystadegau\'r Sgrin Cartref</string>
	<string name="site_settings_unknown_language_code_error">Heb adnabd y cod iaith</string>
	<string name="site_settings_threading_dialog_description">Caniatáu sylwadau i\'w nythu mewn edafedd.</string>
	<string name="site_settings_threading_dialog_header">Edafedd hyd at</string>
	<string name="remove">Tynnu</string>
	<string name="search">Chwilio</string>
	<string name="add_category">Ychwanegu categori</string>
	<string name="disabled">Analluogwyd</string>
	<string name="site_settings_image_original_size">Maint Gwreiddiol</string>
	<string name="privacy_private">Mae eich gwefan yn weladwy i chi yn unig a defnyddwyr rydych wedi eu cymeradwyo</string>
	<string name="privacy_public_not_indexed">Mae eich gwefan yn weladwy i bawb, ond mae\'n gofyn i beiriannau chwilio i beidio mynegeio eich gwefan</string>
	<string name="privacy_public">Mae eich gwefan yn weladwy i bawb, ac o bosib wedi ei fynegeio gan beiriannau chwilio</string>
	<string name="about_me_hint">Ychydig o eiriau amdanoch chi…</string>
	<string name="public_display_name_hint">Bydd yr enw dangos yn defnyddio eich enw defnyddiwr os yw wedi ei osod</string>
	<string name="about_me">Amdanaf fi</string>
	<string name="public_display_name">Enw dangos cyhoeddus</string>
	<string name="my_profile">Fy Mhroffil</string>
	<string name="first_name">Enw cyntaf</string>
	<string name="last_name">Enw olaf</string>
	<string name="site_privacy_public_desc">Caniatáu i beiriannau chwilio fynegeio\'r wefan</string>
	<string name="site_privacy_hidden_desc">Annog peiriannau chwilio i beidio mynegeio\'r wefan</string>
	<string name="site_privacy_private_desc">Hoffwn i fy ngwefan fod yn breifat, yn weladwy yn unig i ddefnyddwyr rwy\'n eu dewis</string>
	<string name="cd_related_post_preview_image">Delwedd sy\'n perthyn ar ôl y rhagolwg</string>
	<string name="error_post_remote_site_settings">Methu cadw manylion y wefan</string>
	<string name="error_fetch_remote_site_settings">Methu estyn manylion y wefan</string>
	<string name="error_media_upload_connection">Digwyddodd gwall cysylltu wrth lwytho\'r cyfrwng</string>
	<string name="site_settings_disconnected_toast">Datgysylltwyd, analluogwyd y golygu.</string>
	<string name="site_settings_unsupported_version_error">Fersiwn o WordPress sydd heb ei gynnal</string>
	<string name="site_settings_multiple_links_dialog_description">Bydd angen cymeradwyaeth ar gyfer sylwadau sy\'n cynnwys mwy na\'r nifer yma o ddolenni.</string>
	<string name="site_settings_close_after_dialog_switch_text">Cau\'n awtomatig</string>
	<string name="site_settings_close_after_dialog_description">Cau\'r sylwadau ar erthyglau yn awtomatig.</string>
	<string name="site_settings_paging_dialog_description">Torri\'r edefyn sylw i dudalennau lluosog.</string>
	<string name="site_settings_paging_dialog_header">Sylwadau fesul tudalen</string>
	<string name="site_settings_close_after_dialog_title">Cau sylwadau</string>
	<string name="site_settings_blacklist_description">Pan fydd sylw yn cynnwys unrhyw un o\'r geiriau hyn yn ei gynnwys, enw, URL, e-bost, neu IP, bydd yn cael ei farcio fel sbam. Gallwch gynnig geiriau rhannol, felly bydd "press" yn canfod "WordPress"</string>
	<string name="site_settings_hold_for_moderation_description">Pan fydd sylw yn cynnwys unrhyw un o\'r geiriau hyn yn ei gynnwys, enw, URL, e-bost neu IP, bydd yn cael ei gadw yn y rhes cymedroli. Gallwch gynnig geiriau rhannol, felly bydd "press" yn canfod "WordPress"</string>
	<string name="site_settings_list_editor_input_hint">Teipiwch air neu ymadrodd</string>
	<string name="site_settings_list_editor_no_items_text">Dim eitemau</string>
	<string name="site_settings_learn_more_caption">Gallwch diystyru\'r gosodiadau hyn ar gyfer cofnodion unigol.</string>
	<string name="site_settings_rp_preview3_site">yn "Diweddariad"</string>
	<string name="site_settings_rp_preview3_title">Canolbwynt Diweddaru: VideoPress ar gyfer Priodasau</string>
	<string name="site_settings_rp_preview2_site">yn "Apiau"</string>
	<string name="site_settings_rp_preview2_title">Mae Ap WordPress Android yn Derbyn Adnewyddiad Sylweddol</string>
	<string name="site_settings_rp_preview1_site">yn "Symudol"</string>
	<string name="site_settings_rp_preview1_title">Diweddariad iPhone/iPad Mawr Nawr ar Gael</string>
	<string name="site_settings_rp_show_images_title">Dangos Delweddau</string>
	<string name="site_settings_rp_show_header_title">Dangos Pennyn</string>
	<string name="site_settings_rp_switch_summary">Mae Cofnodion Perthynol yn dangos cynnwys perthnasol o\'ch gwefan islaw eich cofnodion.</string>
	<string name="site_settings_rp_switch_title">Dangos Cofnodion sy\'n Perthyn</string>
	<string name="site_settings_delete_site_hint">Dileu data eich gwefan o\'r ap</string>
	<string name="site_settings_blacklist_hint">Mae sylwadau sy\'n cyfateb i hidl yn cael eu marcio fel sbam</string>
	<string name="site_settings_moderation_hold_hint">Mae sylwadau sy\'n cyfateb i hidl yn cael gosod yn y rhes cymedroli</string>
	<string name="site_settings_multiple_links_hint">Anwybyddu terfyn dolen gan ddefnyddwyr hysbys</string>
	<string name="site_settings_whitelist_hint">Rhaid i awdur y sylw fod wedi cyfrannu sylw cymeradwy yn y gorffennol</string>
	<string name="site_settings_user_account_required_hint">Rhaid i ddefnyddwyr fod wedi\'u cofrestru ac wedi mewngofnodi cyn cynnig sylw</string>
	<string name="site_settings_identity_required_hint">Rhaid i awdur sylw rhoi enw ac e-bost</string>
	<string name="site_settings_manual_approval_hint">Rhaid i sylwadau gael eu cymeradwyo â llaw</string>
	<string name="site_settings_paging_hint">Dangos sylwadau mewn darnau o faint penodol</string>
	<string name="site_settings_threading_hint">Caniatáu sylwadau nythog i ddyfnder penodol</string>
	<string name="site_settings_sort_by_hint">Pennu\'r drefn mae\'r sylwadau yn cael eu dangos</string>
	<string name="site_settings_close_after_hint">Peidio â chaniatáu sylwadau ar ôl amser penodol</string>
	<string name="site_settings_receive_pingbacks_hint">Caniatáu hysbysiadau dolenni o flogiau eraill</string>
	<string name="site_settings_send_pingbacks_hint">Ceisio hysbysu unrhyw flogiau sy\'n cael eu cysylltu atyn nhw yn yr erthygl</string>
	<string name="site_settings_allow_comments_hint">Caniatáu darllenwyr i gofnodi sylwadau</string>
	<string name="site_settings_discussion_hint">Gweld a newid gosodiadau trafodaethau ar eich gwefannau</string>
	<string name="site_settings_more_hint">Gweld pob gosodiad trafodaeth sydd ar gael</string>
	<string name="site_settings_related_posts_hint">Dangos neu guddio cofnodion cysylltiedig yn y darllenydd</string>
	<string name="site_settings_upload_and_link_image_hint">Galluogi llwytho delwedd maint llawn bob tro</string>
	<string name="site_settings_image_width_hint">Newid maint delweddau mewn cofnodion i\'r lled hwn</string>
	<string name="site_settings_format_hint">Gosod fformat cofnod newydd</string>
	<string name="site_settings_category_hint">Gosod categori cofnod newydd</string>
	<string name="site_settings_location_hint">Ychwanegu data lleoliad yn awtomatig at eich cofnodion</string>
	<string name="site_settings_password_hint">Newid eich cyfrinair</string>
	<string name="site_settings_username_hint">Cyfrif y defnyddiwr cyfredol</string>
	<string name="site_settings_language_hint">Yr iaith mae\'r blog yn cael ei ysgrifennu ynddi yn bennaf</string>
	<string name="site_settings_privacy_hint">Rheoli pwy sy\'n gallu gweld eich gwefan</string>
	<string name="site_settings_address_hint">Nid yw newid eich cyfeiriad yn cael ei gynnal ar hyn o bryd</string>
	<string name="site_settings_tagline_hint">Disgrifiad byr neu ymadrodd bachog i ddisgrifio eich blog</string>
	<string name="site_settings_title_hint">Mewn ychydig eiriau, yn esboniwch beth yw natur y wefan hon</string>
	<string name="site_settings_whitelist_known_summary">Sylwadau gan ddefnyddwyr hysbys</string>
	<string name="site_settings_whitelist_all_summary">Sylwadau gan pob defnyddiwr</string>
	<string name="site_settings_threading_summary">%d lefel</string>
	<string name="site_settings_privacy_private_summary">Preifat</string>
	<string name="site_settings_privacy_hidden_summary">Cudd</string>
	<string name="site_settings_delete_site_title">Dileu Gwefan</string>
	<string name="site_settings_privacy_public_summary">Cyhoeddus</string>
	<string name="site_settings_blacklist_title">Rhestr ddu</string>
	<string name="site_settings_moderation_hold_title">Dal ar gyfer Cymedroli</string>
	<string name="site_settings_multiple_links_title">Dolenni mewn sylwadau</string>
	<string name="site_settings_whitelist_title">Gymeradwyo\'n awtomatig</string>
	<string name="site_settings_threading_title">Edafu</string>
	<string name="site_settings_paging_title">Tudalennu</string>
	<string name="site_settings_sort_by_title">Trefnu yn ôl</string>
	<string name="site_settings_account_required_title">Rhaid llofnodi defnyddwyr</string>
	<string name="site_settings_identity_required_title">Rhaid cynnwys enw ac e-bost</string>
	<string name="site_settings_receive_pingbacks_title">Derbyn Hysbysiad Cyfeirio</string>
	<string name="site_settings_send_pingbacks_title">Anfon Hysbysiadau Cyfeirio</string>
	<string name="site_settings_allow_comments_title">Caniatáu Sylwadau</string>
	<string name="site_settings_default_format_title">Fformat Rhagosodedig</string>
	<string name="site_settings_default_category_title">Categori Rhagosodedig</string>
	<string name="site_settings_location_title">Galluogi Lleoliad</string>
	<string name="site_settings_address_title">Cyfeiriad</string>
	<string name="site_settings_title_title">Teitl y Wefan</string>
	<string name="site_settings_tagline_title">Llinell tag</string>
	<string name="site_settings_this_device_header">Y ddyfais hon</string>
	<string name="site_settings_discussion_new_posts_header">Rhagosodiadau ar gyfer cofnodion ewydd</string>
	<string name="site_settings_account_header">Cyfrif</string>
	<string name="site_settings_writing_header">Ysgrifennu</string>
	<string name="newest_first">Diweddaraf yn gyntaf</string>
	<string name="site_settings_general_header">Cyfredinol</string>
	<string name="discussion">Trafodaeth</string>
	<string name="privacy">Preifatrwydd</string>
	<string name="related_posts">Cofnodion sy\'n Perthyn</string>
	<string name="comments">Sylwadau</string>
	<string name="close_after">Cau ar ôl</string>
	<string name="oldest_first">Hynaf yn gyntaf</string>
	<string name="media_error_no_permission_upload">Nid oes gennych ganiatâd i lwytho cyfrwng i\'r wefan</string>
	<string name="never">Byth</string>
	<string name="unknown">Anhysbys</string>
	<string name="reader_err_get_post_not_found">Nid yw\'r cofnod yma\'n bodoli bellach</string>
	<string name="reader_err_get_post_not_authorized">Nid ydych wedi eich awdurdodi i weld y cofnod hwn</string>
	<string name="reader_err_get_post_generic">Methu estyn y cofnod hwn</string>
	<string name="blog_name_no_spaced_allowed">Nid oes modd i gyfeiriad gwefan gynnwys bylchau</string>
	<string name="invalid_username_no_spaces">Nid oes modd i enw defnyddiwr gynnwys bylchau</string>
	<string name="reader_empty_followed_blogs_no_recent_posts_description">Nid yw\'r gwefannau rydych yn eu dilyn gofnodi dim yn ddiweddar</string>
	<string name="reader_empty_followed_blogs_no_recent_posts_title">Dim cofnodion diweddar</string>
	<string name="media_details_copy_url_toast">URL wedi ei gopïo i\'r clipfwrdd</string>
	<string name="edit_media">Golygu cyfrwng</string>
	<string name="media_details_copy_url">Copïo URL</string>
	<string name="media_details_label_date_uploaded">Wedi ei lwytho</string>
	<string name="media_details_label_date_added">Ychwanegwyd</string>
	<string name="selected_theme">Thema Dewiswyd</string>
	<string name="could_not_load_theme">Methu llwytho\'r thema</string>
	<string name="theme_activation_error">Aeth rhywbeth o\'i le. Methu cychwyn y thema</string>
	<string name="theme_by_author_prompt_append"> gan %1$s</string>
	<string name="theme_prompt">Diolch am ddewis %1$s</string>
	<string name="theme_try_and_customize">Defnyddio a Chyfaddasu</string>
	<string name="theme_view">Golwg</string>
	<string name="theme_details">Manylion</string>
	<string name="theme_support">Cefnogaeth</string>
	<string name="theme_done">GORFFEN</string>
	<string name="theme_manage_site">RHEOLI GWEFAN</string>
	<string name="title_activity_theme_support">Themâu</string>
	<string name="theme_activate">Gweithredu</string>
	<string name="date_range_start_date">Dyddiad Cychwyn</string>
	<string name="date_range_end_date">Dyddiad Gorffen</string>
	<string name="current_theme">Thema Gyfredol</string>
	<string name="customize">Cyfaddasu</string>
	<string name="details">Manylion</string>
	<string name="support">Cefnogaeth</string>
	<string name="active">Gweithredol</string>
	<string name="stats_referrers_spam_generic_error">Aeth rhywbeth o\'i le wrth wneud hynny. Nid yw\'r cyflwr sbam wedi newid.</string>
	<string name="stats_referrers_marking_not_spam">Nodi fel nad sbam</string>
	<string name="stats_referrers_unspam">Nid sbam</string>
	<string name="stats_referrers_marking_spam">Marciwyd fel sbam</string>
	<string name="theme_auth_error_authenticate">Methwyd estyn themâu: methwyd dilysu defnyddiwr</string>
	<string name="post_published">Cyhoeddwyd y cofnod</string>
	<string name="page_published">Cyhoeddwyd y dudalen</string>
	<string name="post_updated">Diweddarwyd y cofnod</string>
	<string name="page_updated">Diweddarwyd y dudalen</string>
	<string name="stats_referrers_spam">Sbam</string>
	<string name="theme_no_search_result_found">Ymddiheuriadau, heb ganfod thema.</string>
	<string name="media_file_name">Enw ffeil: %s</string>
	<string name="media_uploaded_on">Llwythwyd i fyny ar: %s</string>
	<string name="media_dimensions">Dimensiynau: %s</string>
	<string name="upload_queued">Mewn ciw</string>
	<string name="media_file_type">Math o ffeil: %s</string>
	<string name="reader_label_gap_marker">Llwytho rhagor o gofnodion</string>
	<string name="notifications_no_search_results">Dim gwefannau\'n cydweddu â \'%s\'</string>
	<string name="search_sites">Chwilio gwefannau</string>
	<string name="notifications_empty_view_reader">Gweld y Darllennydd</string>
	<string name="unread">Deb ei ddarllen</string>
	<string name="notifications_empty_action_followers_likes">Denu sylw: rhowch sylw ar gofnod rydych wedi ei ddarllen.</string>
	<string name="notifications_empty_action_comments">Ymunwch â sgwrs: rhowch sylw ar flogiau rydych yn eu dilyn.</string>
	<string name="notifications_empty_action_unread">Ail-gynnwch sgwrs: ysgrifennwch gofnod newydd.</string>
	<string name="notifications_empty_action_all">Byddwch egniol! Rhowch sylwadau ar flogiau rydych yn eu dilyn.</string>
	<string name="notifications_empty_likes">Dim hoffi newydd i\'w dangos...eto.</string>
	<string name="notifications_empty_followers">Dim dilynwyr newydd...eto.</string>
	<string name="notifications_empty_comments">Dim sylwadau newydd...eto.</string>
	<string name="notifications_empty_unread">Wedi dal i fyny!</string>
	<string name="stats_widget_error_jetpack_no_blogid">Ewch i\'r Ystadegau yn yr ap a cheisio ychwanegu\'r teclyn yn hwyrach</string>
	<string name="stats_widget_error_readd_widget">Tynnwch y teclyn a\'i ychwanegu eto</string>
	<string name="stats_widget_error_no_visible_blog">Nid oes modd mynd i\'r Ystadegau heb flog gweladwy</string>
	<string name="stats_widget_error_no_permissions">Nid yw eich cyfrif WordPress.com yn cael mynediad i\'r Ystadegau ar y blog</string>
	<string name="stats_widget_error_no_account">Mewngofnodwch i WordPress</string>
	<string name="stats_widget_error_generic">Methu llwytho\'r Ystadegau</string>
	<string name="stats_widget_loading_data">Llwytho data…</string>
	<string name="stats_widget_name_for_blog">Ystadegau %1$s Heddiw</string>
	<string name="stats_widget_name">Ystadegau Heddiw WordPress</string>
	<string name="add_location_permission_required">Caniatâd angenrheidiol er mwyn ychwanegu lleoliad</string>
	<string name="add_media_permission_required">Caniatâd angenrheidiol er mwyn ychwanegu cyfrwng</string>
	<string name="access_media_permission_required">Caniatâd angenrheidiol er mwyn cael mynediad at gyfrwng</string>
	<string name="stats_enable_rest_api_in_jetpack">I weld eich ystadegau, galluogwch y modiwl JSON API yn Jetpack.</string>
	<string name="error_open_list_from_notification">Cafodd y cofnod neu dudalen hwn ei gyhoeddi ar wefan arall</string>
	<string name="reader_short_comment_count_multi">%s Sylw</string>
	<string name="reader_short_comment_count_one">1 Sylw</string>
	<string name="reader_label_submit_comment">ANFON</string>
	<string name="reader_hint_comment_on_post">Ateb cofnod…</string>
	<string name="reader_discover_visit_blog">Mynd i %s</string>
	<string name="reader_discover_attribution_blog">Cofnodwyd yn wreiddiol ar %s</string>
	<string name="reader_discover_attribution_author">Cofnodwyd yn wreiddiol gan %s</string>
	<string name="reader_discover_attribution_author_and_blog">Cofnodwyd yn wreiddiol gan %1$s ar %2$s</string>
	<string name="reader_short_like_count_multi">%s Hoffi</string>
	<string name="reader_short_like_count_one">1 Hoffi</string>
	<string name="reader_label_follow_count">%,d dilynnwr</string>
	<string name="reader_short_like_count_none">Hoffi</string>
	<string name="reader_menu_tags">Golygu tagiau a blogiau</string>
	<string name="reader_title_post_detail">Cofnod Darllennydd</string>
	<string name="local_draft_explainer">Mae\'r cofnod yn ddrafft lleol sydd heb ei gyhoeddi</string>
	<string name="local_changes_explainer">Mae gan y cofnod newidiadau lleol sydd heb eu cyhoeddi</string>
	<string name="notifications_push_summary">Gosodiadau hysbysiadau sy\'n ymddangos ar eich dyfais.</string>
	<string name="notifications_email_summary">Gosodiadau hysbysiadau sy\'n cael eu hanfon at e-bost sy\'n gysylltiedig â\'ch cyfrif.</string>
	<string name="notifications_tab_summary">Gosodiadau hysbysiadau sy\'n ymddangos ar y tab Hysbysiadau.</string>
	<string name="notifications_disabled">Mae hysbysiadau apiau wedi eu hanalluogi. Tapiwch yma i\'w galluogi yn y Gosodiadau.</string>
	<string name="notification_types">Mathau o Hysbysiadau</string>
	<string name="error_loading_notifications">Methu llwytho gosodiadau hysbysiadau</string>
	<string name="replies_to_your_comments">Atebion i\'ch sylwadau</string>
	<string name="comment_likes">Hoffi sylwadau</string>
	<string name="app_notifications">Hysbysiadau apiau</string>
	<string name="notifications_tab">Tab hysbysiadau</string>
	<string name="email">E-bost</string>
	<string name="notifications_comments_other_blogs">Sylwadau ar wefannau eraill</string>
	<string name="notifications_wpcom_updates">Diweddariadau WordPress.com</string>
	<string name="notifications_other">Arall</string>
	<string name="notifications_account_emails">E-bost gan WordPress.com</string>
	<string name="notifications_account_emails_summary">Byddwn yn anfon e-byst pwysig am eich cyfrif a hefyd cewch bethau ychwanegol a defnyddiol.</string>
	<string name="notifications_sights_and_sounds">Golwg a Sain</string>
	<string name="your_sites">Eich Gwefannau</string>
	<string name="stats_insights_latest_post_trend">Mae wedi bod yn %1$s ers cyhoeddi %2$s. Dyma sut mae\'r cofnod wedi performio hyd yma…</string>
	<string name="stats_insights_latest_post_summary">Crynodeb o\'r Cofnod Diweddaraf</string>
	<string name="button_revert">Dychwelyd</string>
	<string name="days_ago">%d diwrnod yn ôl</string>
	<string name="yesterday">Ddoe</string>
	<string name="connectionbar_no_connection">Dim cysylltiad</string>
	<string name="page_trashed">Anfonwyd y dudalen i\'r Sbwriel</string>
	<string name="post_deleted">Dilëwyd y dudalen</string>
	<string name="post_trashed">Anfonwyd y cofnod i\'r Sbwriel</string>
	<string name="stats_no_activity_this_period">Dim gweithgaredd yn ystod y cyfnod hwn</string>
	<string name="trashed">I\'r Sbwriel</string>
	<string name="button_back">Nôl</string>
	<string name="page_deleted">Dilëwyd y dudalen</string>
	<string name="button_stats">Ystadegau</string>
	<string name="button_trash">Sbwriel</string>
	<string name="button_preview">Rhagolwg</string>
	<string name="button_view">Gweld</string>
	<string name="button_edit">Golygu</string>
	<string name="button_publish">Cyhoeddi</string>
	<string name="my_site_no_sites_view_subtitle">Hoffech chi ychwanegu un?</string>
	<string name="my_site_no_sites_view_title">Nid oes gennych wefannau WordPress eto.</string>
	<string name="my_site_no_sites_view_drake">Darlun</string>
	<string name="reader_toast_err_follow_blog_not_authorized">Nid oes gennych hawl i gael mynediad at y blog hwn</string>
	<string name="reader_toast_err_follow_blog_not_found">Nid oedd modd canfod y blog hwn</string>
	<string name="undo">Dadwneud</string>
	<string name="tabbar_accessibility_label_my_site">Fy Ngwefan</string>
	<string name="tabbar_accessibility_label_me">Fi</string>
	<string name="passcodelock_prompt_message">Rhowch eich PIN</string>
	<string name="editor_toast_changes_saved">Mae\'r newidiadau wedi eu cadw</string>
	<string name="push_auth_expired">Daeth y cais i ben. Mewngofnodwch i WordPress.com a cheisio eto.</string>
	<string name="stats_insights_best_ever">Golygon Gorau Erioed</string>
	<string name="ignore">Anwybyddu</string>
	<string name="stats_insights_most_popular_percent_views">%1$d%% golwg</string>
	<string name="stats_insights_most_popular_hour">Awr mwyaf poblogaidd</string>
	<string name="stats_insights_most_popular_day">Diwrnod mwyaf poblogaidd</string>
	<string name="stats_insights_popular">Diwrnod ac awr mwyaf poblogaidd</string>
	<string name="stats_insights_today">Ystadegau Heddiw</string>
	<string name="stats_insights_all_time">Cofnodion, golygon ac ymwelwyr erioed</string>
	<string name="stats_insights">Mewnwelediadau</string>
	<string name="stats_sign_in_jetpack_different_com_account">I weld eich ystadegau, mewngofnodwch i\'r cyfrif WordPress.com rydych wedi ei ddefnyddio i gysylltu Jetpack.</string>
	<string name="stats_other_recent_stats_moved_label">Chwilio am eich Ystadegau Diweddar Eraill? Mae nhw wedi eu symud i\'r dudalen Mewnwelediad.</string>
	<string name="me_disconnect_from_wordpress_com">Datgysylltwch o WordPress.com</string>
	<string name="me_connect_to_wordpress_com">Cysylltwch i WordPress.com</string>
	<string name="me_btn_login_logout">Mewngofnodi/Allgofnodi</string>
	<string name="account_settings">Gosodiadau\'r Cyfrif</string>
	<string name="me_btn_support">Cymorth a Chefnogaeth</string>
	<string name="site_picker_cant_hide_current_site">Nid oedd "%s" wedi ei guddio gan taw hi yw\'r wefan gyfredol</string>
	<string name="site_picker_create_dotcom">Creu gwefan WordPress.com</string>
	<string name="site_picker_add_site">Ychwanegu gwefan</string>
	<string name="site_picker_add_self_hosted">Ychwanegu gwefan hunanwesteio</string>
	<string name="site_picker_edit_visibility">Dangos/cuddio gwefannau</string>
	<string name="my_site_btn_view_admin">Gweld Gweinyddu</string>
	<string name="my_site_btn_view_site">Gweld Gwefan</string>
	<string name="site_picker_title">Dewis gwefan</string>
	<string name="my_site_btn_switch_site">Newid Gwefan</string>
	<string name="my_site_btn_blog_posts">Cofnodion Blog</string>
	<string name="my_site_btn_site_settings">Gosodiadau</string>
	<string name="my_site_header_look_and_feel">Golwg a Theimlad</string>
	<string name="my_site_header_publish">Cyhoeddi</string>
	<string name="my_site_header_configuration">Ffurfweddiad</string>
	<string name="reader_label_new_posts_subtitle">Tapio i\'w dangos</string>
	<string name="notifications_account_required">Mewngofnodi i WordPress.com am hysbysiadau</string>
	<string name="stats_unknown_author">Awdur Anhysbys</string>
	<string name="image_added">Ychwanegwyd delwedd</string>
	<string name="signout">Datgysylltu</string>
	<string name="deselect_all">Dad-ddewis y cyfan</string>
	<string name="show">Dangos</string>
	<string name="hide">Cuddio</string>
	<string name="select_all">Dewis y cyfan</string>
	<string name="sign_out_wpcom_confirm">Bydd datgysylltu eich cyfrif yn tynnu holl fanylion WordPress.com @%s o\'r ddyfais hon, gan gynnwys drafftiau a newidiadau lleol.</string>
	<string name="select_from_new_picker">Dewis lluosog gyda dewisydd newydd</string>
	<string name="stats_generic_error">Methu llwytho\'r ystadegau angenrheidiol</string>
	<string name="no_device_videos">Dim fideos</string>
	<string name="no_blog_images">Dim delweddau</string>
	<string name="no_blog_videos">Dim fideos</string>
	<string name="no_device_images">Dim delweddau</string>
	<string name="error_loading_blog_images">Methu estyn delweddau</string>
	<string name="error_loading_blog_videos">Methu estyn fideos</string>
	<string name="error_loading_images">Gwall wrth lwytho delweddau</string>
	<string name="error_loading_videos">Gwall wrth lwytho fideos</string>
	<string name="loading_blog_images">Estyn delweddau</string>
	<string name="loading_blog_videos">Estyn fideos</string>
	<string name="no_media_sources">Methu estyn y cyfrwng</string>
	<string name="loading_videos">Llwytho fideos</string>
	<string name="loading_images">Llwytho delweddau</string>
	<string name="no_media">Dim cyfrwng</string>
	<string name="device">Dyfais</string>
	<string name="language">Iaith</string>
	<string name="add_to_post">Ychwanegu at Gofnod</string>
	<string name="media_picker_title">Dewis cyfrwng</string>
	<string name="take_photo">Cymryd llun</string>
	<string name="take_video">Cymryd fideo</string>
	<string name="tab_title_device_images">Delweddau Dyfais</string>
	<string name="tab_title_device_videos">Fideos Dyfais</string>
	<string name="tab_title_site_images">Delweddau Gwefan</string>
	<string name="tab_title_site_videos">Fideos Gwefan</string>
	<string name="media_details_label_file_name">Enw ffeil</string>
	<string name="media_details_label_file_type">Math o ffeil</string>
	<string name="error_publish_no_network">Methu cyhoeddi heb gysylltiad. Cadw fel drafft.</string>
	<string name="editor_toast_invalid_path">Llwybr ffeil annilys</string>
	<string name="verification_code">Cod dilysu</string>
	<string name="invalid_verification_code">Cod dilysu annilys</string>
	<string name="verify">Dilysu</string>
	<string name="two_step_footer_label">Rhowch y cod o\'ch ap dilysu.</string>
	<string name="two_step_footer_button">Anfonwch god drwy neges testun</string>
	<string name="two_step_sms_sent">Gwiriwch eich neges testun am god dilysu.</string>
	<string name="sign_in_jetpack">Mewngofnodwch i\'ch cyfrif WordPress.com i gysylltu â Jetpack.</string>
	<string name="auth_required">Mewngofnodwch eto i barhau.</string>
	<string name="reader_empty_posts_request_failed">Methu adfer cofnodion</string>
	<string name="publisher">Cyhoeddwr:</string>
	<string name="error_notification_open">Methu agor hysbysiadau</string>
	<string name="stats_followers_total_email_paged">Dangos %1$d - %2$d o %3$s Dilynwr E-bost</string>
	<string name="stats_search_terms_unknown_search_terms">Termau Chwilio Anhysbys</string>
	<string name="stats_followers_total_wpcom_paged">Dangos %1$d - %2$d o %3$s Dilynwr WordPress.com</string>
	<string name="stats_empty_search_terms_desc">Dysgwch ragor am eich traffig chwilio drwy edrych ar eiriau defnyddiodd eich ymwelwyr i ddod o hyd i\'ch gwefan.</string>
	<string name="stats_empty_search_terms">Heb gofnodi geiriau chwilio</string>
	<string name="stats_entry_search_terms">Gair Chwilio</string>
	<string name="stats_view_authors">Awduron</string>
	<string name="stats_view_search_terms">Geiriau Chwilio</string>
	<string name="comments_fetching">Estyn sylwadau…</string>
	<string name="pages_fetching">Estyn tudalennau…</string>
	<string name="toast_err_post_uploading">Methu agor cofnod tra ei fod yn llwytho</string>
	<string name="posts_fetching">Estyn cofnodion…</string>
	<string name="media_fetching">Estyn cyfrwng…</string>
	<string name="post_uploading">Llwytho</string>
	<string name="stats_total">Cyfanswm</string>
	<string name="stats_overall">O\'r Cyfan</string>
	<string name="stats_period">Cyfnod</string>
	<string name="logs_copied_to_clipboard">Cofnodion y rhaglen wedi\'u copïo i\'r clipfwrdd</string>
	<string name="reader_label_new_posts">Cofnodion newydd</string>
	<string name="reader_empty_posts_in_blog">Mae\'r blog yn wag</string>
	<string name="stats_average_per_day">Cyfartaledd Diwrnod</string>
	<string name="stats_recent_weeks">Wythnosau Diweddar</string>
	<string name="error_copy_to_clipboard">Digwyddodd gwall wrth gopïo testun i\'r clipfwrdd</string>
	<string name="reader_page_recommended_blogs">Gwefannau fyddech chi\'n eu hoffi</string>
	<string name="stats_months_and_years">Misoedd a Blynyddoedd</string>
	<string name="themes_fetching">Estyn themâu…</string>
	<string name="stats_for">Ystadegau %s</string>
	<string name="stats_other_recent_stats_label">Ystadegau Diweddar Eraill</string>
	<string name="stats_view_all">Gweld y cyfan</string>
	<string name="stats_view">Gweld</string>
	<string name="stats_followers_months">%1$d mis</string>
	<string name="stats_followers_a_year">Blwyddyn</string>
	<string name="stats_followers_years">%1$d blwyddyn</string>
	<string name="stats_followers_a_month">Mis</string>
	<string name="stats_followers_minutes">%1$d munud</string>
	<string name="stats_followers_an_hour_ago">awr yn ôl</string>
	<string name="stats_followers_hours">%1$d awr</string>
	<string name="stats_followers_a_day">Diwrnod</string>
	<string name="stats_followers_days">%1$d diwrnod</string>
	<string name="stats_followers_a_minute_ago">munud yn ôl</string>
	<string name="stats_followers_seconds_ago">eiliad yn ôl</string>
	<string name="stats_followers_total_email">Cyfanswm Dilynwyr E-bost: %1$s</string>
	<string name="stats_followers_wpcom_selector">WordPress.com</string>
	<string name="stats_followers_email_selector">E-bost</string>
	<string name="stats_followers_total_wpcom">Cyfanswm Dilynwyr WordPress.com: %1$s</string>
	<string name="stats_comments_total_comments_followers">Cyfanswm cofnodion gyda sylwadau dilynwyr: %1$s</string>
	<string name="stats_comments_by_authors">Yn ôl Awdur</string>
	<string name="stats_comments_by_posts_and_pages">Yn ôl Cofnod a Thudalen</string>
	<string name="stats_empty_followers_desc">Cadwch gyfrif o\'ch niferoedd o ddilynwyr a pha mor hir mae bob un wedi bod yn dilyn eich gwefan.</string>
	<string name="stats_empty_followers">Dim dilynwyr</string>
	<string name="stats_empty_publicize_desc">Cadwch gyfrif o\'ch niferoedd o ddilynwyr o\'r rhwydweithiau cymdeithasol amrywilo gan ddefnyddio publicize.</string>
	<string name="stats_empty_publicize">Dim dilynwyr publicize wedi ei cofnodi</string>
	<string name="stats_empty_video">Dim fideos wedi eu chwarae</string>
	<string name="stats_empty_video_desc">Os ydych wedi llwytho fideos drwy VideoPress, gweld sawl gwaith mae nhw wedi cael eu gwylio.</string>
	<string name="stats_empty_comments_desc">Os ydych yn caniatáu sylwadau ar eich gwefan, dilynwch eich prif sylwebwyr a deall pa gynnwys sy\'n achosi\'r sgyrsiau mwyaf brwd, ar sail y 1000 sylw diweddaraf.</string>
	<string name="stats_empty_tags_and_categories_desc">Derbyn trosolwg o\'r pynciau mwyaf poblogaidd ar eich gwefan, yn ôl y prif gofnodion yn ystod yr wythnos diwethaf.</string>
	<string name="stats_empty_top_authors_desc">Dilyn golygon ar gofnodion eich cyfrannwyr ac edrych yn fanwl ar gynnwys mwyaf poblogaidd pob awdur.</string>
	<string name="stats_empty_tags_and_categories">Dim cofnodion wedi\'u tagio na thudalennau wedi eu darllen</string>
	<string name="stats_empty_clicks_desc">Pan mae eich cynnwys yn cynnwys dolenni i wefannau eraill, byddwch yn gweld pa rai mae eich ymwelwyr yn clicio arnynt amlaf.</string>
	<string name="stats_empty_referrers_desc">Dysgu rhagor am welededd eich gwefan drwy edrych ar y gwefannau a pheiriannau chwilio sy\'n anfon y mwyaf o draffig atoch</string>
	<string name="stats_empty_clicks_title">Dim cliciau wedi eu cofnodi</string>
	<string name="stats_empty_referrers_title">Dim cyfeirwyr wedi eu cofnodi</string>
	<string name="stats_empty_top_posts_title">Dim cofnodion na thudalennau wedi eu darllen</string>
	<string name="stats_empty_top_posts_desc">Canfod pa gynnwys sydd wedi ei ddarllen fwyaf a gweld sut mae cofnodion unigol a thudalennau\'n perfformio dros amser.</string>
	<string name="stats_totals_followers">Ers</string>
	<string name="stats_empty_geoviews">Heb gofnodi gwledydd</string>
	<string name="stats_empty_geoviews_desc">Gweld o\'r rhestr i weld pa wledydd ac ardaloedd sy\'n cynhyrchu\'r mwyaf o draffig i\'ch gwefan.</string>
	<string name="stats_entry_video_plays">Fideo</string>
	<string name="stats_entry_top_commenter">Awdur</string>
	<string name="stats_entry_publicize">Gwasanaeth</string>
	<string name="stats_entry_followers">Dilynwr</string>
	<string name="stats_totals_publicize">Dilynwyr</string>
	<string name="stats_entry_clicks_link">Dolen</string>
	<string name="stats_view_top_posts_and_pages">Cofnod a Thudalen</string>
	<string name="stats_view_videos">Fideos</string>
	<string name="stats_view_publicize">Publicize</string>
	<string name="stats_view_followers">Dilynwyr</string>
	<string name="stats_view_countries">Gwledydd</string>
	<string name="stats_likes">Hoffi</string>
	<string name="stats_pagination_label">Tudalen %1$s o %2$s</string>
	<string name="stats_timeframe_years">Blwyddyn</string>
	<string name="stats_views">Golwg</string>
	<string name="stats_visitors">Ymwelwyr</string>
	<string name="ssl_certificate_details">Manylion</string>
	<string name="delete_sure_post">Dileu\'r cofnod</string>
	<string name="delete_sure">Dileu\'r drafft</string>
	<string name="delete_sure_page">Dileu\'r dudalen</string>
	<string name="confirm_delete_multi_media">Dileu\'r eitemau hyn?</string>
	<string name="confirm_delete_media">Dileu\'r eitem hon?</string>
	<string name="cab_selected">%d wedi eu dewis</string>
	<string name="media_gallery_date_range">Dangos cyfrwng o %1$s hyd %2$s</string>
	<string name="sure_to_remove_account">Tynnu\'r blog?</string>
	<string name="reader_empty_followed_blogs_title">Nid ydych yn dilyn unrhyw wefan hyd yn hyn</string>
	<string name="reader_empty_posts_liked">Nid ydych wedi hoffi unrhyw gofnod</string>
	<string name="faq_button">Cwestiynnau Cyffredin</string>
	<string name="browse_our_faq_button">Porwch ein Cwestiynnau Cyffredin</string>
	<string name="nux_help_description">Ewch i\'n canolfan gymorth i gael atebion i\'r cwestiynnau mwyaf cyffredin neu i\'n fforymau i ofyn rhai newydd</string>
	<string name="agree_terms_of_service">Drwy greu cyfrif rydych y cytuno â\'r %1$sAmodau Gwasanaeth%2$s difyr</string>
	<string name="create_new_blog_wpcom">Creu blog WordPress.com</string>
	<string name="new_blog_wpcom_created">Mae\'r blog WordPress.com wedi ei greu!</string>
	<string name="reader_empty_comments">Dim sylwadau eto</string>
	<string name="reader_empty_posts_in_tag">Dim cofnod gyda\'r tag hwn</string>
	<string name="reader_label_comment_count_multi">%,d sylw</string>
	<string name="reader_label_view_original">Darllen yr erthygl wreiddiol</string>
	<string name="reader_label_like">Hoffi</string>
	<string name="reader_label_comment_count_single">Un sylw</string>
	<string name="reader_label_comments_closed">Mae\'r sylwadau wedi cau</string>
	<string name="reader_label_comments_on">Sylwadau ar</string>
	<string name="reader_title_photo_viewer">%1$d o %2$d</string>
	<string name="error_publish_empty_post">Methu cyhoeddi cofnod gwag</string>
	<string name="error_refresh_unauthorized_posts">Nid oes gennych ganiatâd i weld na golygu cofnodion</string>
	<string name="error_refresh_unauthorized_pages">Nid oes gennych ganiatâd i weld na golygu tudalennau</string>
	<string name="error_refresh_unauthorized_comments">Nid oes gennych ganiatâd i weld na golygu sylwadau</string>
	<string name="older_month">Mwy na mis</string>
	<string name="more">Rhagor</string>
	<string name="older_two_days">Mwy na 2 ddiwrnod</string>
	<string name="older_last_week">Mwy nag wythnos</string>
	<string name="stats_no_blog">Nid oedd modd llwytho ystadegau\'r blog dan sylw</string>
	<string name="select_a_blog">Dewis gwefan WordPress</string>
	<string name="sending_content">Llwytho cynnwys %s</string>
	<string name="uploading_total">Llwytho %1$d o %2$d</string>
	<string name="mnu_comment_liked">Hoffi</string>
	<string name="comment">Sylw</string>
	<string name="comment_trashed">Gosod y sylw yn y sbwriel</string>
	<string name="posts_empty_list">Dim cofnod eto. Beth am greu un?</string>
	<string name="comment_reply_to_user">Ateb %s</string>
	<string name="pages_empty_list">Dim tudalen eto. Beth am greu un?</string>
	<string name="media_empty_list_custom_date">Dim cyfrwng yn y cyfnod hwn</string>
	<string name="posting_post">Cofnodi "%s"</string>
	<string name="signing_out">Allgofnodi…</string>
	<string name="reader_toast_err_generic">Methu cyflawni\'r weithred hon</string>
	<string name="reader_toast_err_block_blog">Methu rhwystro\'r blog hwn</string>
	<string name="reader_toast_blog_blocked">Ni fydd cofnodion o\'r blog yn cael eu dangos bellach</string>
	<string name="reader_menu_block_blog">Rhwstro\'r blog</string>
	<string name="contact_us">Cysylltu â ni</string>
	<string name="hs__conversation_detail_error">Disgrifiwch eich anhawster</string>
	<string name="hs__new_conversation_header">Cefnogaeth drwy sgwrs</string>
	<string name="hs__conversation_header">Cefnogaeth drwy sgwrs</string>
	<string name="hs__username_blank_error">Rhowch enw dilys</string>
	<string name="hs__invalid_email_error">Rhowch gyfeiriad e-bost dilys</string>
	<string name="add_location">Ychwanegwch leoliad</string>
	<string name="current_location">Lleoliad cyfredol</string>
	<string name="search_location">Chwilio</string>
	<string name="edit_location">Golygu</string>
	<string name="search_current_location">Lleoli</string>
	<string name="preference_send_usage_stats">Anfon ystadegau</string>
	<string name="preference_send_usage_stats_summary">Anfonwch ystadegau defnydd i\'n cynorthwyo i wella WordPress Android</string>
	<string name="update_verb">Diweddaru</string>
	<string name="schedule_verb">Amserlen</string>
	<string name="reader_title_blog_preview">Blog Darllenydd</string>
	<string name="reader_title_tag_preview">Tag Darllenydd</string>
	<string name="reader_title_subs">Tagiau a Blogiau</string>
	<string name="reader_page_followed_tags">Tagiau sy\'n cael eu dilyn</string>
	<string name="reader_page_followed_blogs">Gwefannau sy\'n cael eu dilyn</string>
	<string name="reader_hint_add_tag_or_url">Rhowch URL neu dag i\'w ddilyn</string>
	<string name="reader_label_followed_blog">Blogiau rwy\'n eu diyn</string>
	<string name="reader_label_tag_preview">Cofnodion wedi\'u tagio %s</string>
	<string name="reader_toast_err_get_blog_info">Methu dangos y blog</string>
	<string name="reader_toast_err_already_follow_blog">Rydych eisoes yn dilyn blog hwn</string>
	<string name="reader_toast_err_follow_blog">Methu dilyn y blog hwn</string>
	<string name="reader_toast_err_unfollow_blog">Methu peidio â dilyn y blog hwn</string>
	<string name="reader_empty_recommended_blogs">Dim blogiau cymeradwy</string>
	<string name="saving">Cadw…</string>
	<string name="media_empty_list">Dim cyfrwng</string>
	<string name="ptr_tip_message">Cyngor: Tynnwch i lawr i\'w adnewyddu</string>
	<string name="help">Cymorth</string>
	<string name="forgot_password">Wedi colli eich cyfrinair?</string>
	<string name="forums">Fforymau</string>
	<string name="help_center">Canolfan gymorth</string>
	<string name="ssl_certificate_error">Tystysgrif SSL annilys</string>
	<string name="ssl_certificate_ask_trust">Os ydych fel arfer yn cysylltu â\'r wefan hon heb broblemau, gall y gwall hwn olygu bod rhywun yn ceisio dynwared y wefan a dylech chi beidio parhau. Hoffech chi ymddiried yn y dystysgrif beth bynnag?</string>
	<string name="out_of_memory">Dim cof ar ôl</string>
	<string name="no_network_message">Nid oes rhwydwaith ar gael</string>
	<string name="could_not_remove_account">Methu tynnu\'r blog</string>
	<string name="gallery_error">Methu estyn y cyfrwng</string>
	<string name="blog_not_found">Digwyddodd gwall wrth geisio cael mynediad at y blog</string>
	<string name="wait_until_upload_completes">Arhoswch nes bod y llwytho i fyny wedi cwblhau</string>
	<string name="theme_fetch_failed">Methu estyn themâu</string>
	<string name="theme_set_failed">Methu gosod thema</string>
	<string name="theme_auth_error_message">Sicrhewch bod gennych breintiau gosod themâu</string>
	<string name="comments_empty_list">Dim sylwadau</string>
	<string name="mnu_comment_unspam">Nid sbam</string>
	<string name="no_site_error">Methwyd cysylltu â gwefan WordPress</string>
	<string name="adding_cat_failed">Methodd ychwanegu categori</string>
	<string name="adding_cat_success">Ychwanegwyd categori yn llwyddiannus</string>
	<string name="cat_name_required">Mae angen maes enw categori</string>
	<string name="category_automatically_renamed">Nid yw enw categori %1$s yn ddilys. Mae wedi ei ail-enwi i%2$s.</string>
	<string name="no_account">Heb ganfod cyfrif WordPress, ychwanegwch cyfrif a cheisiwch eto</string>
	<string name="sdcard_message">Mae angen cerdyn SD gosodedig i lwytho cyfryngau</string>
	<string name="stats_empty_comments">Dim sylwadau eto</string>
	<string name="stats_bar_graph_empty">Dim ystadegau gael</string>
	<string name="invalid_url_message">Gwiriwch fod URL y blog yn ddilys</string>
	<string name="reply_failed">Methodd yr ateb</string>
	<string name="notifications_empty_list">Dim hysbysiadau</string>
	<string name="error_delete_post">Digwyddodd gwall wrth ddileu y%s</string>
	<string name="error_refresh_posts">Nid oedd modd adnewyddu\'r cofnodion ar hyn o bryd</string>
	<string name="error_refresh_pages">Nid oedd modd adnewyddu\'r tudalennau ar hyn o bryd</string>
	<string name="error_refresh_notifications">Nid oedd modd adnewyddu\'r hysbysiadau ar hyn o bryd</string>
	<string name="error_refresh_comments">Nid oedd modd adnewyddu\'r cofnodion ar hyn o bryd</string>
	<string name="error_refresh_stats">Nid oedd modd adnewyddu\'r ystadegau ar hyn o bryd</string>
	<string name="error_generic">Digwyddodd gwall</string>
	<string name="error_moderate_comment">Digwyddodd gwall wrth gymedroli</string>
	<string name="error_edit_comment">Digwyddodd gwall wrth olygu\'r sylw</string>
	<string name="error_upload">Digwyddodd gwall wrth lwytho\'r %s</string>
	<string name="error_load_comment">Methu llwytho\'r sylw</string>
	<string name="error_downloading_image">Gwall wrth lwytho delwedd i lawr</string>
	<string name="passcode_wrong_passcode">PIN anghywir</string>
	<string name="invalid_email_message">Nid yw eich cyfeiriad e-bost yn ddilys</string>
	<string name="invalid_password_message">Rhaid i enw defnyddiwr gynnwys o leiaf yn 4 nod</string>
	<string name="invalid_username_too_short">Rhaid i enw defnyddiwr fod o leiaf yn 4 nod o hyd</string>
	<string name="invalid_username_too_long">Rhaid i enw defnyddiwr fod yn llai na 61 nod</string>
	<string name="username_only_lowercase_letters_and_numbers">Gall enwau defnyddiwr gynnwys dim ond llythrennau bach (a-z) a rhifau</string>
	<string name="username_required">Rhowch enw defnyddiwr</string>
	<string name="username_not_allowed">Nid yw\'r enw defnyddiwr yna yn cael ei ganiatáu</string>
	<string name="username_must_be_at_least_four_characters">Rhaid i enw defnyddiwr fod o leiaf 4 nod</string>
	<string name="username_contains_invalid_characters">Nid yw enw defnyddiwr yn gallu cynnwys y nod “_”</string>
	<string name="username_must_include_letters">Rhiad i enw defnyddiwr gynnwys o leiaf 1 llythyren (a-z)</string>
	<string name="email_invalid">Rhowch gyfeiriad e-bost dilys</string>
	<string name="email_not_allowed">Nid yw\'r cyfeiriad e-bost yna yn cael ei ganiatáu</string>
	<string name="username_exists">Mae\'r enw defnyddiwr yna\'n bodoli eisoes</string>
	<string name="email_exists">Mae\'r cyfeiriad e-bost yna eisoes yn cael ei ddefnyddio</string>
	<string name="username_reserved_but_may_be_available">Mae\'r enw defnyddiwr yna wedi\'i neilltuo ar hyn o bryd ond efallai y bydd ar gael ymhen ychydig o ddyddiau</string>
	<string name="blog_name_required">Rhowch gyfeiriad gwefan</string>
	<string name="blog_name_not_allowed">Nid yw\'r cyfeiriad gwefan yna\'n cael ei ganiatáu</string>
	<string name="blog_name_must_be_at_least_four_characters">Rhaid i gyfeiriad gwefan fod o leiaf 4 nod</string>
	<string name="blog_name_must_be_less_than_sixty_four_characters">Rhaid i gyfeiriad y wefan fod yn llai na 64 nod</string>
	<string name="blog_name_contains_invalid_characters">Nid yw cyfeiriad gwefan yn gallu cynnwys y nod “_”</string>
	<string name="blog_name_cant_be_used">Nid oes modd i chi ddefnyddio\'r cyfeiriad gwefan hwn</string>
	<string name="blog_name_only_lowercase_letters_and_numbers">Gall cyfeiriad gwefan gynnwys dim ond llythrennau bach (a-z) a rhifau</string>
	<string name="blog_name_exists">Mae\'r cyfeiriad gwefan hwnnw\'n bodoli eisoes</string>
	<string name="blog_name_reserved">Mae\'r wefan wedi ei neilltuo</string>
	<string name="blog_name_reserved_but_may_be_available">Mae\'r wefan yna wedi\'i neilltuo ar hyn o bryd ond efallai y bydd ar gael ymhen ychydig o ddyddiau</string>
	<string name="username_or_password_incorrect">Mae\'r enw defnyddiwr neu gyfrinair yn anghywir</string>
	<string name="nux_cannot_log_in">Nid oes modd i ni eich mewngofnodi</string>
	<string name="xmlrpc_error">Methwyd cysylltu. Rhowch y llwybr llawn i xmlrpc.php ar eich gwefan a cheisiwch eto.</string>
	<string name="select_categories">Dewis categorïau</string>
	<string name="account_details">Manylion cyfrif</string>
	<string name="edit_post">Golygu cofnod</string>
	<string name="add_comment">Ychwanegu sylw</string>
	<string name="connection_error">Gwall cysylltu</string>
	<string name="cancel_edit">Diddymu golygu</string>
	<string name="scaled_image_error">Rhowch werth graddfa lled ddilys</string>
	<string name="post_not_found">Digwyddodd gwall wrth lwytho\'r cofnod. Adnewyddwch eich cofnodion a cheisiwch eto.</string>
	<string name="learn_more">Dysgu rhagor</string>
	<string name="media_gallery_settings_title">Gosodiadau\'r oriel</string>
	<string name="media_gallery_image_order">Trefn delweddau</string>
	<string name="media_gallery_num_columns">Nifer y colofnau</string>
	<string name="media_gallery_type_thumbnail_grid">Grid lluniau bach</string>
	<string name="media_gallery_edit">Golygu\'r oriel</string>
	<string name="media_error_no_permission">Nid oes gennych ganiatâd i weld y llyfrgell cyfryngau</string>
	<string name="cannot_delete_multi_media_items">Nid oes modd dileu rhai cyfryngau ar hyn o bryd. Ceisiwch eto yn nes ymlaen.</string>
	<string name="themes_live_preview">Rhagolwg byw</string>
	<string name="theme_current_theme">Y thema bresennol</string>
	<string name="theme_premium_theme">Themâu premiwm</string>
	<string name="link_enter_url_text">Testun dolen (dewisol)</string>
	<string name="create_a_link">Creu dolen</string>
	<string name="page_settings">Gosodiadau tudalen</string>
	<string name="local_draft">Drafft lleol</string>
	<string name="upload_failed">Methodd y llwytho</string>
	<string name="horizontal_alignment">Alinio llorweddol</string>
	<string name="file_not_found">Methu canfod y ffeil cyfryngau i\'w llwytho i fyny. A yw wedi ei dileu neu ei symud?</string>
	<string name="post_settings">Gosodiadau cofnodion</string>
	<string name="delete_post">Dileu\'r cofnod</string>
	<string name="delete_page">Dileu\'r dudalen</string>
	<string name="comment_status_approved">Cymeradwy</string>
	<string name="comment_status_unapproved">Dan ystyriaeth</string>
	<string name="comment_status_spam">Sbam</string>
	<string name="comment_status_trash">Gosodwyd yn y sbwriel</string>
	<string name="edit_comment">Golygu sylw</string>
	<string name="mnu_comment_approve">Cymeradwyo</string>
	<string name="mnu_comment_unapprove">Anghymeradwyo</string>
	<string name="mnu_comment_spam">Sbam</string>
	<string name="mnu_comment_trash">Sbwriel</string>
	<string name="dlg_approving_comments">Cymeradwyo</string>
	<string name="dlg_unapproving_comments">Anghymeradwyo</string>
	<string name="dlg_spamming_comments">Marcio fel sbam</string>
	<string name="dlg_trashing_comments">Anfon i\'r sbwriel</string>
	<string name="dlg_confirm_trash_comments">Anfon i\'r sbwriel?</string>
	<string name="trash_yes">Sbwriel</string>
	<string name="trash_no">Peidiwch â\'u hanfon i\'r sbwriel</string>
	<string name="trash">Sbwriel</string>
	<string name="author_name">Enw awdur</string>
	<string name="author_email">E-bost awdur</string>
	<string name="author_url">URL Awdur</string>
	<string name="hint_comment_content">Sylw</string>
	<string name="saving_changes">Cadw\'r newidiadau</string>
	<string name="sure_to_cancel_edit_comment">Diddymu golygu\'r sylw hwn?</string>
	<string name="content_required">Mae angen sylw</string>
	<string name="toast_comment_unedited">Nid yw\'r sylw wedi newid</string>
	<string name="remove_account">Tynnu\'r blog</string>
	<string name="blog_removed_successfully">Tynwyd y blog yn llwyddiannus</string>
	<string name="delete_draft">Dileu\'r drafft</string>
	<string name="preview_page">Rhagolwg tudalen</string>
	<string name="preview_post">Rhagolwg post</string>
	<string name="comment_added">Sylw wedi ei ychwanegu\'n llwyddiannus</string>
	<string name="post_not_published">Nid yw statws cofnod wedi ei gyhoeddi</string>
	<string name="page_not_published">Nid yw statws tudalen wedi ei gyhoeddi</string>
	<string name="view_in_browser">Gweld mewn porwr</string>
	<string name="add_new_category">Ychwanegu categori newydd</string>
	<string name="category_name">Enw categori</string>
	<string name="category_slug">Categori bonyn (dewisol)</string>
	<string name="category_desc">Disgrifiad categori (dewisol)</string>
	<string name="category_parent">Categori rhiant (dewisol):</string>
	<string name="share_action_post">Cofnod newydd</string>
	<string name="share_action_media">Llyfrgell cyfrwng</string>
	<string name="file_error_create">Methwyd creu ffeil dros dro ar gyfer llwytho cyfryngau. Gwnewch yn siwr bod digon o le rhydd ar eich dyfais.</string>
	<string name="location_not_found">Lleoliad anhysbys</string>
	<string name="open_source_licenses">Trwyddedau cod agored</string>
	<string name="invalid_site_url_message">Gwiriwch fod URL y blog yn ddilys</string>
	<string name="pending_review">Disgwyl adolygiad</string>
	<string name="http_credentials">Cymwysterau HTTP (dewisol)</string>
	<string name="http_authorization_required">Mae angen awdurdodi</string>
	<string name="post_format">Fformat cofnod</string>
	<string name="notifications_empty_all">Dim hysbysiadau...eto.</string>
	<string name="new_post">Cofnod newydd</string>
	<string name="new_media">Cyfryngau newydd</string>
	<string name="view_site">Gweld y wefan</string>
	<string name="privacy_policy">Polisi preifatrwydd</string>
	<string name="local_changes">Newidiadau lleol</string>
	<string name="image_settings">Gosodiadau delweddau</string>
	<string name="add_account_blog_url">Cyfeiriad y blog</string>
	<string name="wordpress_blog">Blog WordPress</string>
	<string name="error_blog_hidden">Mae\'r blog hwn yn gudd ac nid oes modd ei lwytho. Galluogwch y blog eto o fewn y gosodiadau a cheisiwch eto.</string>
	<string name="fatal_db_error">Digwyddodd gwall wrth greu cronfa ddata\'r ap. Ceisiwch ailosod yr ap.</string>
	<string name="jetpack_message_not_admin">Mae angen yr ategyn Jetpack ar gyfer adrodd ar yr ystadegau. Cysylltwch â gweinyddwr y wefan.</string>
	<string name="reader_title_applog">Cofnod yr ap</string>
	<string name="reader_share_link">Rhannu dolen</string>
	<string name="reader_toast_err_add_tag">Methu ychwanegu\'r tag hwn</string>
	<string name="reader_toast_err_remove_tag">Methu tynnu\'r tag hwn</string>
	<string name="required_field">Maes angenrheidiol</string>
	<string name="email_hint">Cyfeiriad e-bost</string>
	<string name="site_address">Eich cyfeiriad hunan-letya (URL)</string>
	<string name="email_cant_be_used_to_signup">Nid oes modd i chi ddefnyddio\'r cyfeiriad e-bost yna i ymuno. Mae gennym anhawster ohonynt yn rhwystro rhai o\'n e-byst. Defnyddiwch darparwr e-bost arall.</string>
	<string name="email_reserved">Mae\'r cyfeiriad e-bost hwnnw eisoes wedi cael ei ddefnyddio. Gwiriwch eich blwch derbyn ar gyfer e-bost cychwyn. Os nad ydych yn cychwyn yn fuan gallwch roi cynnig arall ymhen ychydig ddyddiau.</string>
	<string name="blog_name_must_include_letters">Rhaid i gyfeiriad gwefan gynnwys o leiaf 1 llythyren (a-z)</string>
	<string name="blog_name_invalid">Cyfeiriad gwefan annilys</string>
	<string name="blog_title_invalid">Teitl gwefan annilys</string>
	<string name="deleting_page">Wrthi\'n dileu tudalen</string>
	<string name="deleting_post">Wrthi\'n dileu cofnod</string>
	<string name="share_url_post">Rhannu cofnod</string>
	<string name="share_url_page">Rhannu tudalen</string>
	<string name="share_link">Rhannu dolen</string>
	<string name="creating_your_account">Creu eich cyfrif</string>
	<string name="creating_your_site">Creu eich gwefan</string>
	<string name="reader_empty_posts_in_tag_updating">Estyn cofnodion…</string>
	<string name="error_refresh_media">Aeth rhywbeth o\'i le wrth adnewyddu\'r llyfrgell cyfryngau. Rhowch gynnig arall arni\'n nes ymlaen.</string>
	<string name="reader_likes_you_and_multi">Rydych chi a %,d o bobl eraill yn hoffi hwn</string>
	<string name="reader_likes_multi">%,d o pobl yn hoffi hwn</string>
	<string name="reader_toast_err_get_comment">Methu adfer y sylw hwn</string>
	<string name="reader_label_reply">Ateb</string>
	<string name="video">Fideo</string>
	<string name="download">Wrthi\'n llwytho i lawr cyfryngau</string>
	<string name="comment_spammed">Mae\'r sylw hwn wedi ei farcio fel sbam</string>
	<string name="cant_share_no_visible_blog">Nid oes modd rhannu i WordPress heb flog gweladwy</string>
	<string name="select_time">Dewis amser</string>
	<string name="reader_likes_you_and_one">Rydych chi ac eraill yn hoffi hwn</string>
	<string name="reader_empty_followed_blogs_description">Ond peidiwch â phoeni, tapiwch yr eicon tag ar y brig de i ddechrau darganfod!</string>
	<string name="select_date">Dewis dyddiad</string>
	<string name="pick_photo">Dewis ffoto</string>
	<string name="account_two_step_auth_enabled">Mae dilysu dau gam wedi ei alluogi ar gyfer y cyfrif hwn. Ewch i\'ch eich gosodiadau diogelwch ar WordPress.com a chrëwch gyfrinair rhaglen benodol.</string>
	<string name="pick_video">Dewiswch fideo</string>
	<string name="reader_toast_err_get_post">Does dim modd adfer y cofnod hwn</string>
	<string name="validating_user_data">Dilysu data defnyddiwr</string>
	<string name="validating_site_data">Dilysu data gwefan</string>
	<string name="password_invalid">Mae angen cyfrinair mwy diogel arnoch chi. Gwnewch yn siŵr eich bod yn defnyddio 7 nod neu fwy, cymysgedd o briflythyren a llythrennau bach, rhifau neu nodau arbennig.</string>
	<string name="nux_tap_continue">Parhau</string>
	<string name="nux_welcome_create_account">Creu cyfrif</string>
	<string name="signing_in">Mewngofnodi…</string>
	<string name="nux_add_selfhosted_blog">Ychwanegu gwefan hunan-letya</string>
	<string name="nux_oops_not_selfhosted_blog">Mewngofnodi i WordPress.com</string>
	<string name="media_add_popup_title">Ychwanegu at y llyfrgell cyfryngau</string>
	<string name="media_add_new_media_gallery">Creu oriel</string>
	<string name="empty_list_default">Mae\'r rhestr hon yn wag</string>
	<string name="select_from_media_library">Dewiswch o\'r llyfrgell cyfryngau</string>
	<string name="jetpack_message">Mae angen yr ategyn Jetpack ar gyfer adrodd ar yr ystadegau. Hoffech chi osod Jetpack?</string>
	<string name="jetpack_not_found">Heb ganfod ategyn jetpack</string>
	<string name="reader_untitled_post">(Dideitl)</string>
	<string name="reader_share_subject">Rhannu o %s</string>
	<string name="reader_btn_share">Rhannu</string>
	<string name="reader_btn_follow">Dilyn</string>
	<string name="reader_btn_unfollow">Yn dilyn</string>
	<string name="reader_hint_comment_on_comment">Ateb sylw…</string>
	<string name="reader_label_added_tag">Ychwanegu %s</string>
	<string name="reader_label_removed_tag">Tynnu %s</string>
	<string name="reader_likes_one">Mae un person yn hoffi hwn</string>
	<string name="reader_likes_only_you">Rydych chi\'n hoffi hwn</string>
	<string name="reader_toast_err_comment_failed">Methu cofnodi\'ch sylw</string>
	<string name="reader_toast_err_tag_exists">Rydych eisoes yn dilyn y tag hwn</string>
	<string name="reader_toast_err_tag_invalid">Nid yw\'n dag dilys</string>
	<string name="reader_toast_err_share_intent">Methu â rhannu</string>
	<string name="reader_toast_err_view_image">Methu â gweld delwedd</string>
	<string name="reader_toast_err_url_intent">Methu agor %s</string>
	<string name="reader_empty_followed_tags">Nid ydych yn dlyn unrhyw dagiau</string>
	<string name="create_account_wpcom">Creu cyfrif ar WordPress.com</string>
	<string name="button_next">Nesaf</string>
	<string name="connecting_wpcom">Cysylltu â WordPress.com</string>
	<string name="username_invalid">Enw defnyddiwr annilys</string>
	<string name="limit_reached">Wedi cyrraedd y terfyn. Gallwch geisio eto mewn 1 munud. Bydd ceisio eto cyn yn cynyddu amser fydd gennych cyn codi\'r gwaharddiad. Os ydych chi\'n credu bod hwn yn gamgymeriad, cysylltwch â Cymorth.</string>
	<string name="nux_tutorial_get_started_title">Cychwyn arni!</string>
	<string name="themes">Themâu</string>
	<string name="all">Y Cyfan</string>
	<string name="images">Delweddau</string>
	<string name="unattached">Heb ei atodi</string>
	<string name="custom_date">Dyddiad Cyfaddas</string>
	<string name="media_add_popup_capture_photo">Cipio ffoto</string>
	<string name="media_add_popup_capture_video">Cipio fideo</string>
	<string name="media_gallery_image_order_random">Hap</string>
	<string name="media_gallery_image_order_reverse">Gwrthdroi</string>
	<string name="media_gallery_type">Math</string>
	<string name="media_gallery_type_squares">Sgwariau</string>
	<string name="media_gallery_type_tiled">Teils</string>
	<string name="media_gallery_type_circles">Cylchoedd</string>
	<string name="media_gallery_type_slideshow">Sioe sleidiau</string>
	<string name="media_edit_title_text">Teitl</string>
	<string name="media_edit_caption_text">Egluryn</string>
	<string name="media_edit_description_text">Disgrifiad</string>
	<string name="media_edit_title_hint">Rhowch deitl yma</string>
	<string name="media_edit_caption_hint">Rhowch egluryn yma</string>
	<string name="media_edit_description_hint">Rhowch ddisgrifiad yma</string>
	<string name="media_edit_success">Diweddarwyd</string>
	<string name="media_edit_failure">Methwyd diweddaru</string>
	<string name="themes_details_label">Manylion</string>
	<string name="themes_features_label">Nodweddion</string>
	<string name="theme_activate_button">Cychwyn</string>
	<string name="theme_activating_button">Wrthi\'n cychwyn</string>
	<string name="theme_set_success">Gosodwyd y thema\'n llwyddiannus!</string>
	<string name="theme_auth_error_title">Methwyd estyn themâu</string>
	<string name="post_excerpt">Dyfyniad</string>
	<string name="share_action_title">Ychwanegu at …</string>
	<string name="share_action">Rhannu</string>
	<string name="stats">Ystadegau</string>
	<string name="stats_view_visitors_and_views">Ymwelwyr a Golygon</string>
	<string name="stats_view_clicks">Cliciau</string>
	<string name="stats_view_tags_and_categories">Tagiau a Chategorïau</string>
	<string name="stats_view_referrers">Cyfeirwyr</string>
	<string name="stats_timeframe_today">Heddiw</string>
	<string name="stats_timeframe_yesterday">Ddoe</string>
	<string name="stats_timeframe_days">Diwrnod</string>
	<string name="stats_timeframe_weeks">Wythnos</string>
	<string name="stats_timeframe_months">Mis</string>
	<string name="stats_entry_country">Gwlad</string>
	<string name="stats_entry_posts_and_pages">Teitl</string>
	<string name="stats_entry_tags_and_categories">Pwnc</string>
	<string name="stats_entry_authors">Awdur</string>
	<string name="stats_entry_referrers">Cyfeiriwr</string>
	<string name="stats_totals_views">Golwg</string>
	<string name="stats_totals_clicks">Cliciau</string>
	<string name="stats_totals_plays">Chwarae</string>
	<string name="passcode_manage">Rheoli clo PIN</string>
	<string name="passcode_enter_passcode">Rhowch eich PIN</string>
	<string name="passcode_enter_old_passcode">Rhowch eich hen PIN</string>
	<string name="passcode_re_enter_passcode">Ail gyflwynwch eich PIN</string>
	<string name="passcode_change_passcode">Newid PIN</string>
	<string name="passcode_set">PIN wedi ei osod</string>
	<string name="passcode_preference_title">Clo PIN</string>
	<string name="passcode_turn_off">Diffodd clo PIN</string>
	<string name="passcode_turn_on">Troi clo PIN ymlaen</string>
	<string name="upload">Llwytho i fyny</string>
	<string name="discard">Gwaredu</string>
	<string name="sign_in">Mewngofnodi</string>
	<string name="notifications">Hysbysiadau</string>
	<string name="note_reply_successful">Ateb wedi ei gyhoeddi</string>
	<string name="follows">Yn Dilyn</string>
	<string name="new_notifications">%d hysbysiadau newydd</string>
	<string name="more_notifications">a %d yn rhagor.</string>
	<string name="loading">Llwytho…</string>
	<string name="httpuser">Enw defnyddiwr HTTP</string>
	<string name="httppassword">Cyfrinair HTTP</string>
	<string name="error_media_upload">Digwyddodd gwall wrth lwytho\'r cyfrwng</string>
	<string name="post_content">Cynnwys (tapiwch i ychwanegu testun a chyfrwng)</string>
	<string name="publish_date">Cyhoeddi</string>
	<string name="content_description_add_media">Ychwanegu cyfrwng</string>
	<string name="incorrect_credentials">Enw cyfrif neu gyfrinair anghywir.</string>
	<string name="password">Cyfrinair</string>
	<string name="username">Enw defnyddiwr</string>
	<string name="reader">Darllennydd</string>
	<string name="featured">Defnyddio fel delwedd nodwedd</string>
	<string name="featured_in_post">Cynnwys delwedd yng nghynnwys y cofnod</string>
	<string name="no_network_title">Dim rhwydwaith ar gael</string>
	<string name="pages">Tudalennau</string>
	<string name="caption">Egluryn (dewisol)</string>
	<string name="width">Lled</string>
	<string name="posts">Cofnodion</string>
	<string name="anonymous">Di-enw</string>
	<string name="page">Tudalen</string>
	<string name="post">Cofnod</string>
	<string name="blogusername">blogusername</string>
	<string name="ok">Iawn</string>
	<string name="upload_scaled_image">Llwytho a chysylltu â delwedd graddedig</string>
	<string name="scaled_image">Lled y ddelwedd graddedig</string>
	<string name="scheduled">Amserlennwyd</string>
	<string name="link_enter_url">URL</string>
	<string name="uploading">Llwytho...</string>
	<string name="version">Fersiwn</string>
	<string name="tos">Amodau Gwasanaeth</string>
	<string name="app_title">WordPress ar gyfer Android</string>
	<string name="max_thumbnail_px_width">Lled Rhagosodedig y Ddelwedd</string>
	<string name="image_alignment">Alinio</string>
	<string name="refresh">Adnewyddu</string>
	<string name="untitled">Dideitl</string>
	<string name="edit">Golygu</string>
	<string name="post_id">Cofnod</string>
	<string name="page_id">Tudalen</string>
	<string name="post_password">Cyfrinair (dewisol)</string>
	<string name="immediately">Ar unwaith</string>
	<string name="quickpress_add_alert_title">Gosod enw\'r llwybr byr</string>
	<string name="today">Heddiw</string>
	<string name="settings">Gosodiadau</string>
	<string name="share_url">Rhannu URL</string>
	<string name="quickpress_window_title">Dewiswch flog ar gyfer llwybr byr QuickPress</string>
	<string name="quickpress_add_error">Nid yw enw\'r llwybr byr yn gallu bod yn wag</string>
	<string name="publish_post">Cyhoeddi</string>
	<string name="draft">Drafft</string>
	<string name="post_private">Preifat</string>
	<string name="upload_full_size_image">Llwytho a\'u cysylltu â delwedd llawn</string>
	<string name="title">Teitl</string>
	<string name="tags_separate_with_commas">Tagiau (gwahanu tagiau gydag atalnodau)</string>
	<string name="categories">Categorïau</string>
	<string name="dlg_deleting_comments">Dileu sylwadau</string>
	<string name="notification_blink">Fflachio\'r golau hysbysu</string>
	<string name="notification_sound">Sain hysbysu</string>
	<string name="notification_vibrate">Dirgrynu</string>
	<string name="status">Statws</string>
	<string name="location">Lleoliad</string>
	<string name="sdcard_title">Mae angen cerdyn SD</string>
	<string name="select_video">Dewiswch fideo o\'r oriel</string>
	<string name="media">Cyfrwng</string>
	<string name="delete">Dileu</string>
	<string name="none">Dim</string>
	<string name="blogs">Blogiau</string>
	<string name="select_photo">Dewiswch lun o\'r oriel</string>
	<string name="error">Gwall</string>
	<string name="cancel">Diddymu</string>
	<string name="save">Cadw</string>
	<string name="add">Ychwanegu</string>
	<string name="category_refresh_error">Gwall adnewyddu categori</string>
	<string name="preview">Rhagolwg</string>
	<string name="on">ar</string>
	<string name="reply">Ateb</string>
	<string name="notification_settings">Gosodiadau Hysbysiadau</string>
	<string name="yes">Iawn</string>
	<string name="no">Na</string>
</resources>
